# Install required packages
!pip install langchain langchain-openai langchain-community yfinance pandas numpy matplotlib seaborn plotly gradio faiss-cpu python-dotenv requests fredapi newsapi-python --quiet

# Core Python Libraries
import os
import json
import warnings
import logging
import time
import ssl
import urllib3
import contextlib
import traceback
import io
from typing import Dict, List, Any, Optional
from datetime import datetime, timedelta

# Data Analysis and Visualization
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
import seaborn as sns
import plotly.graph_objects as go
import plotly.express as px

# Environment and Configuration
from dotenv import load_dotenv

# LangChain Core
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import BaseTool, tool
from langchain.memory import ConversationBufferWindowMemory
from langchain.schema import BaseMessage, HumanMessage, AIMessage
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.docstore.document import Document

# LangChain Azure OpenAI
from langchain_openai import AzureChatOpenAI, AzureOpenAIEmbeddings

# LangChain Community (Vector Store)
from langchain_community.vectorstores import FAISS

# External Data Sources
import yfinance as yf
from newsapi import NewsApiClient
from fredapi import Fred

# Web Interface
import gradio as gr

# Jupyter/IPython Display
from IPython.display import display, Markdown, HTML, Image

# HTTP Clients
import requests
import requests.sessions

# Load environment variables
load_dotenv()

# Configure Matplotlib for Proper Display
plt.style.use('default')
sns.set_palette("husl")
plt.rcParams['figure.figsize'] = (12, 8)
plt.rcParams['font.size'] = 10

# Configure logging for clean output
warnings.filterwarnings('ignore')
logging.basicConfig(level=logging.INFO)

# Suppress verbose logging from external libraries
external_loggers = [
    "httpx",
    "azure.core.pipeline.policies.http_logging_policy", 
    "azure.identity",
    "urllib3"
]

for logger_name in external_loggers:
    logging.getLogger(logger_name).setLevel(logging.WARNING)

@contextlib.contextmanager
def suppress_llm_logs():
    """Context manager to suppress verbose LLM logging during execution"""
    original_levels = {}
    
    # Store original log levels
    for logger_name in external_loggers:
        logger = logging.getLogger(logger_name)
        original_levels[logger_name] = logger.level
        logger.setLevel(logging.WARNING)
    
    try:
        yield
    finally:
        # Restore original levels
        for logger_name, level in original_levels.items():
            logging.getLogger(logger_name).setLevel(level)

print("[SYSTEM] All libraries imported successfully")

[SYSTEM] All libraries imported successfully

# Configuration from environment variables
AZURE_OPENAI_API_KEY = os.getenv('AZURE_OPENAI_API_KEY')
AZURE_OPENAI_ENDPOINT = os.getenv('AZURE_OPENAI_ENDPOINT')
AZURE_OPENAI_ROUTER_DEPLOYMENT_NAME = os.getenv('AZURE_OPENAI_ROUTER_DEPLOYMENT_NAME')
AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME = os.getenv('AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME')
AZURE_OPENAI_ROUTER_API_VERSION = os.getenv('AZURE_OPENAI_ROUTER_API_VERSION', '2024-02-15-preview')
AZURE_OPENAI_API_VERSION = os.getenv('AZURE_OPENAI_API_VERSION', '2024-02-15-preview')
AZURE_OPENAI_EMBEDDING_API_VERSION = os.getenv('AZURE_OPENAI_EMBEDDING_API_VERSION', '2024-02-15-preview')

ALPHA_VANTAGE_API_KEY = os.getenv('ALPHA_VANTAGE_API_KEY')
NEWS_API_KEY = os.getenv('NEWSAPI_KEY')
FRED_API_KEY = os.getenv('FRED_API_KEY')
SEC_API_KEY = os.getenv('SEC_API_KEY')

# Initialize Azure OpenAI
llm = AzureChatOpenAI(
    azure_endpoint=AZURE_OPENAI_ENDPOINT,
    azure_deployment=AZURE_OPENAI_ROUTER_DEPLOYMENT_NAME,
    openai_api_version=AZURE_OPENAI_ROUTER_API_VERSION,
    openai_api_key=AZURE_OPENAI_API_KEY
)
print(f"Azure OpenAI LLM initialized successfully using model: {AZURE_OPENAI_ROUTER_DEPLOYMENT_NAME}")

# Initialize embeddings for vector database
embeddings = AzureOpenAIEmbeddings(
    azure_endpoint=AZURE_OPENAI_ENDPOINT,
    azure_deployment=AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME,
    openai_api_version=AZURE_OPENAI_EMBEDDING_API_VERSION,
    openai_api_key=AZURE_OPENAI_API_KEY
)
print(f"Azure OpenAI Embeddings initialized successfully using model: {AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME}")

print("[SYSTEM] Environment setup completed successfully")

Azure OpenAI LLM initialized successfully using model: model-router
Azure OpenAI Embeddings initialized successfully using model: text-embedding-3-small
[SYSTEM] Environment setup completed successfully

class AgentMemory:
    """persistent memory system using FAISS vector database with intelligent caching."""
    
    def __init__(self, memory_path: str = "./database/agent_memory"):
        self.memory_path = memory_path
        self.vector_store = None
        self.data_cache = {}  # In-memory cache for quick lookups
        self.cache_expiry = 3600  # 1 hour cache expiry for data
        self.analysis_cache_expiry = 7200  # 2 hours for analysis results
        self.initialize_memory()
    
    def initialize_memory(self):
        """Initialize or load existing memory."""
        try:
            # Try to load existing memory
            if os.path.exists(f"{self.memory_path}.faiss"):
                self.vector_store = FAISS.load_local(self.memory_path, embeddings)
                print("[MEMORY] Loaded existing agent memory with cached data")
            else:
                # Create new memory with initial documents
                initial_docs = [
                    Document(page_content="Investment analysis requires considering multiple factors: technical indicators, fundamental analysis, market sentiment, and economic conditions.", 
                            metadata={"type": "general_knowledge", "timestamp": datetime.now().isoformat()})
                ]
                self.vector_store = FAISS.from_documents(initial_docs, embeddings)
                self.save_memory()
                print("Created new agent memory with caching enabled")
        except Exception as e:
            print(f"Error initializing memory: {e}")
            # Fallback: create minimal memory
            initial_docs = [
                Document(page_content="Fallback memory initialized", 
                        metadata={"type": "system", "timestamp": datetime.now().isoformat()})
            ]
            self.vector_store = FAISS.from_documents(initial_docs, embeddings)
    
    def _generate_cache_key(self, data_type: str, symbol: str, **params) -> str:
        """Generate a unique cache key for data requests."""
        # Create a consistent key from parameters
        param_str = "_".join([f"{k}_{v}" for k, v in sorted(params.items())])
        return f"{data_type}_{symbol}_{param_str}".lower()
    
    def _is_cache_valid(self, timestamp_str: str, cache_type: str = "data") -> bool:
        """Check if cached data is still valid."""
        try:
            cache_time = datetime.fromisoformat(timestamp_str)
            current_time = datetime.now()
            expiry_time = self.cache_expiry if cache_type == "data" else self.analysis_cache_expiry
            return (current_time - cache_time).total_seconds() < expiry_time
        except:
            return False
    
    def get_cached_data(self, data_type: str, symbol: str, **params) -> Optional[str]:
        """Retrieve cached data if available and valid."""
        try:
            cache_key = self._generate_cache_key(data_type, symbol, **params)
            
            # First check in-memory cache
            if cache_key in self.data_cache:
                cache_entry = self.data_cache[cache_key]
                if self._is_cache_valid(cache_entry['timestamp']):
                    print(f"[CACHE] Using cached {data_type} data | Symbol: {symbol}")
                    return cache_entry['data']
                else:
                    # Remove expired cache
                    del self.data_cache[cache_key]
            
            # Search vector database for cached results
            search_query = f"{data_type} data for {symbol} {' '.join(str(v) for v in params.values())}"
            memories = self.vector_store.similarity_search(search_query, k=3)
            
            for memory in memories:
                metadata = memory.metadata
                if (metadata.get('type') == 'cached_data' and 
                    metadata.get('data_type') == data_type and 
                    metadata.get('symbol', '').lower() == symbol.lower() and
                    metadata.get('cache_key') == cache_key):
                    
                    if self._is_cache_valid(metadata.get('timestamp', ''), 'data'):
                        # Cache in memory for faster future access
                        self.data_cache[cache_key] = {
                            'data': memory.page_content,
                            'timestamp': metadata['timestamp']
                        }
                        print(f"[CACHE] Retrieved cached {data_type} data | Symbol: {symbol} | Source: Vector DB")
                        return memory.page_content
            
            return None
        except Exception as e:
            print(f"[CACHE] Error retrieving cached data: {e}")
            return None
    
    def cache_data(self, data_type: str, symbol: str, data: str, **params):
        """Cache data in both memory and vector database."""
        try:
            cache_key = self._generate_cache_key(data_type, symbol, **params)
            timestamp = datetime.now().isoformat()
            
            # Store in memory cache
            self.data_cache[cache_key] = {
                'data': data,
                'timestamp': timestamp
            }
            
            # Store in vector database
            metadata = {
                'type': 'cached_data',
                'data_type': data_type,
                'symbol': symbol,
                'cache_key': cache_key,
                'timestamp': timestamp,
                **{f"param_{k}": str(v) for k, v in params.items()}
            }
            
            doc = Document(page_content=data, metadata=metadata)
            self.vector_store.add_documents([doc])
            self.save_memory()
            
            print(f"[CACHE] Stored {data_type} data | Symbol: {symbol}")
        except Exception as e:
            print(f"[CACHE] Error caching data: {e}")
    
    def get_cached_analysis(self, analysis_type: str, symbol: str, request_hash: str) -> Optional[Dict[str, Any]]:
        """Retrieve cached analysis results."""
        try:
            search_query = f"{analysis_type} analysis for {symbol}"
            memories = self.vector_store.similarity_search(search_query, k=5)
            
            for memory in memories:
                metadata = memory.metadata
                if (metadata.get('type') == 'cached_analysis' and 
                    metadata.get('analysis_type') == analysis_type and 
                    metadata.get('symbol', '').lower() == symbol.lower() and
                    metadata.get('request_hash') == request_hash):
                    
                    if self._is_cache_valid(metadata.get('timestamp', ''), 'analysis'):
                        try:
                            cached_result = json.loads(memory.page_content)
                            print(f"[CACHE] Using cached {analysis_type} analysis | Symbol: {symbol}")
                            return cached_result
                        except json.JSONDecodeError:
                            continue
            
            return None
        except Exception as e:
            print(f"[CACHE] Error retrieving cached analysis: {e}")
            return None
    
    def cache_analysis(self, analysis_type: str, symbol: str, analysis_result: Dict[str, Any], request_hash: str):
        """Cache analysis results."""
        try:
            metadata = {
                'type': 'cached_analysis',
                'analysis_type': analysis_type,
                'symbol': symbol,
                'request_hash': request_hash,
                'timestamp': datetime.now().isoformat(),
                'execution_time': analysis_result.get('execution_time', 0)
            }
            
            doc = Document(page_content=json.dumps(analysis_result), metadata=metadata)
            self.vector_store.add_documents([doc])
            self.save_memory()

            print(f"[CACHE] Stored {analysis_type} analysis | Symbol: {symbol}")
        except Exception as e:
            print(f"[CACHE] Error caching analysis: {e}")
    
    def add_memory(self, content: str, metadata: Dict[str, Any]):
        """Add new memory to the vector store."""
        try:
            doc = Document(page_content=content, metadata=metadata)
            self.vector_store.add_documents([doc])
            self.save_memory()
        except Exception as e:
            print(f"[MEMORY] Error adding memory: {e}")
    
    def search_memory(self, query: str, k: int = 5) -> List[Document]:
        """Search for relevant memories."""
        try:
            return self.vector_store.similarity_search(query, k=k)
        except Exception as e:
            print(f"[MEMORY] Error searching memory: {e}")
            return []
    
    def cleanup_expired_cache(self):
        """Clean up expired cache entries from memory."""
        try:
            current_time = datetime.now()
            expired_keys = []
            
            for key, entry in self.data_cache.items():
                if not self._is_cache_valid(entry['timestamp']):
                    expired_keys.append(key)
            
            for key in expired_keys:
                del self.data_cache[key]
            
            if expired_keys:
                print(f"[CACHE] Cleaned up {len(expired_keys)} expired cache entries")
        except Exception as e:
            print(f"[CACHE] Error cleaning cache: {e}")
    
    def get_cache_stats(self) -> Dict[str, Any]:
        """Get cache statistics."""
        try:
            memories = self.vector_store.similarity_search("cached", k=100)
            cached_data_count = sum(1 for m in memories if m.metadata.get('type') == 'cached_data')
            cached_analysis_count = sum(1 for m in memories if m.metadata.get('type') == 'cached_analysis')
            
            return {
                'in_memory_cache_size': len(self.data_cache),
                'vector_db_cached_data': cached_data_count,
                'vector_db_cached_analyses': cached_analysis_count,
                'total_memories': len(memories)
            }
        except Exception as e:
            print(f"[CACHE] Error getting cache stats: {e}")
            return {}
    
    def save_memory(self):
        """Save memory to disk."""
        try:
            self.vector_store.save_local(self.memory_path)
        except Exception as e:
            print(f"[MEMORY] Error saving memory: {e}")

# Initialize global memory
agent_memory = AgentMemory()
print("[SYSTEM] Agent memory system initialized")

Created new agent memory with caching enabled
[SYSTEM] Agent memory system initialized

# Yahoo Finance Tool with Caching
@tool
def get_stock_data(symbol: str, period: str = "1y") -> str:
    """Get stock price data and basic financial information from Yahoo Finance.
    
    Args:
        symbol: Stock symbol (e.g., 'AAPL', 'MSFT')
        period: Time period ('1d', '5d', '1mo', '3mo', '6mo', '1y', '2y', '5y', '10y', 'ytd', 'max')
    """
    try:
        # Check cache first
        cached_data = agent_memory.get_cached_data('stock_data', symbol, period=period)
        if cached_data:
            return cached_data
        
        # Fetch fresh data if not cached
        stock = yf.Ticker(symbol)
        hist = stock.history(period=period)
        info = stock.info
        
        # Check if we have sufficient data
        if hist.empty or len(hist) < 2:
            return f"Error: Insufficient price data for {symbol}"
        
        current_price = hist['Close'].iloc[-1]
        price_change = hist['Close'].iloc[-1] - hist['Close'].iloc[-2]
        price_change_pct = (price_change / hist['Close'].iloc[-2]) * 100

        print(f"[DATA] Stock data retrieved for {symbol} from Yahoo Finance")

        # Convert pandas/numpy types to native Python types for JSON serialization
        result = {
            'symbol': symbol,
            'current_price': float(round(current_price, 2)),
            'price_change': float(round(price_change, 2)),
            'price_change_pct': float(round(price_change_pct, 2)),
            'volume': int(hist['Volume'].iloc[-1]) if pd.notna(hist['Volume'].iloc[-1]) else 0,
            'market_cap': info.get('marketCap', 'N/A'),
            'pe_ratio': info.get('trailingPE', 'N/A'),
            'company_name': info.get('longName', 'N/A'),
            'sector': info.get('sector', 'N/A'),
            'industry': info.get('industry', 'N/A'),
            # Add historical price data for technical analysis (last 50 days)
            'price_history': [float(price) for price in hist['Close'].tail(50).tolist()],
            'volume_history': [int(vol) if pd.notna(vol) else 0 for vol in hist['Volume'].tail(50).tolist()],
            'high_52_week': float(hist['High'].max()),
            'low_52_week': float(hist['Low'].min()),
            'avg_volume': int(hist['Volume'].mean()) if not hist['Volume'].isna().all() else 0
        }
        
        result_json = json.dumps(result, indent=2)

        agent_memory.cache_data('stock_data', symbol, result_json, period=period)
        
        return result_json
    
    except Exception as e:
        return f"Error fetching stock data for {symbol}: {str(e)}"

# News API Tool with Caching
@tool
def get_stock_news(symbol: str, days: int = 7) -> str:
    """Get recent news articles related to a stock symbol.
    
    Args:
        symbol: Stock symbol to search news for
        days: Number of days to look back for news
    """
    try:
        # Check cache first (with shorter cache time for news)
        cached_data = agent_memory.get_cached_data('stock_news', symbol, days=days)
        if cached_data:
            return cached_data
        
        # Configure SSL handling for NewsAPI
        # Disable SSL warnings and verification for NewsAPI (development/testing only)
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
        
        # Create custom session with SSL configuration
        session = requests.sessions.Session()
        session.verify = False  # Disable SSL verification for NewsAPI
        
        # Alternative direct requests approach to avoid NewsApiClient SSL issues
        from_date = (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d')
        
        url = "https://newsapi.org/v2/everything"
        params = {
            'q': symbol,
            'language': 'en',
            'sortBy': 'relevancy',
            'from': from_date,
            'pageSize': 10,
            'apiKey': NEWS_API_KEY
        }
        
        response = session.get(url, params=params, verify=False, timeout=30)
        response.raise_for_status()
        data = response.json()
        
        if data.get('status') != 'ok':
            return f"Error: NewsAPI returned status: {data.get('status')} - {data.get('message', 'Unknown error')}"
        
        news_items = []
        articles = data.get('articles', [])
        for article in articles[:5]:  # Top 5 articles
            if article.get('title') and article.get('description'):
                news_items.append({
                    'title': article['title'],
                    'description': article['description'],
                    'source': article.get('source', {}).get('name', 'Unknown'),
                    'published_at': article.get('publishedAt', ''),
                    'url': article.get('url', '')
                })
        
        result_json = json.dumps(news_items, indent=2)
        
        print(f"[DATA] News retrieved for {symbol} from NewsAPI")

        # Cache the result (news has shorter cache time due to freshness requirements)
        agent_memory.cache_data('stock_news', symbol, result_json, days=days)
        
        return result_json
    
    except Exception as e:
        return f"Error fetching news for {symbol}: {str(e)}"

# FRED Economic Data Tool with Caching
@tool
def get_economic_data(series_id: str = "GDP") -> str:
    """Get economic data from FRED (Federal Reserve Economic Data).
    
    Args:
        series_id: FRED series ID (e.g., 'GDP', 'UNRATE', 'FEDFUNDS', 'CPIAUCSL')
    """
    try:
        # Check cache first
        cached_data = agent_memory.get_cached_data('economic_data', series_id)
        if cached_data:
            return cached_data
        
        fred = Fred(api_key=FRED_API_KEY)
        data = fred.get_series(series_id, limit=12)  # Last 12 observations
        
        # Check if we have sufficient data
        if data.empty or len(data) < 2:
            return f"Error: Insufficient economic data for series {series_id}"
        
        # Convert pandas/numpy types to native Python types for JSON serialization
        result = {
            'series_id': series_id,
            'latest_value': float(data.iloc[-1]),
            'latest_date': data.index[-1].strftime('%Y-%m-%d'),
            'previous_value': float(data.iloc[-2]),
            'change': float(data.iloc[-1] - data.iloc[-2]),
            'change_pct': float((data.iloc[-1] - data.iloc[-2]) / data.iloc[-2] * 100),
            'historical_data': [float(val) for val in data.tolist()]
        }
        
        result_json = json.dumps(result, indent=2)

        print(f"[DATA] Economic data cached for {series_id}")

        # Cache the result
        agent_memory.cache_data('economic_data', series_id, result_json)
        
        return result_json
    
    except Exception as e:
        return f"Error fetching economic data for {series_id}: {str(e)}"

# Alpha Vantage Tool with Caching
@tool
def get_alpha_vantage_data(symbol: str, function: str = "TIME_SERIES_DAILY") -> str:
    """Get financial data from Alpha Vantage API.
    
    Args:
        symbol: Stock symbol
        function: Alpha Vantage function (e.g., 'TIME_SERIES_DAILY', 'OVERVIEW', 'INCOME_STATEMENT')
    """
    try:
        # Check cache first
        cached_data = agent_memory.get_cached_data('alpha_vantage', symbol, function=function)
        if cached_data:
            return cached_data
        
        base_url = "https://www.alphavantage.co/query"
        params = {
            'function': function,
            'symbol': symbol,
            'apikey': ALPHA_VANTAGE_API_KEY
        }
        
        response = requests.get(base_url, params=params)
        data = response.json()
        
        # Return a simplified version to avoid token limits
        if function == "OVERVIEW":
            overview = {
                'symbol': data.get('Symbol', 'N/A'),
                'market_cap': data.get('MarketCapitalization', 'N/A'),
                'pe_ratio': data.get('PERatio', 'N/A'),
                'peg_ratio': data.get('PEGRatio', 'N/A'),
                'dividend_yield': data.get('DividendYield', 'N/A'),
                'eps': data.get('EPS', 'N/A'),
                '52_week_high': data.get('52WeekHigh', 'N/A'),
                '52_week_low': data.get('52WeekLow', 'N/A')
            }
            result_json = json.dumps(overview, indent=2)
        else:
            result_json = json.dumps(data, indent=2)[:1000]  # Truncate to avoid token limits
        
        print(f"[DATA] Alpha Vantage data retrieved for {symbol} function {function}")

        # Cache the result
        agent_memory.cache_data('alpha_vantage', symbol, result_json, function=function)
        
        return result_json
    
    except Exception as e:
        return f"Error fetching Alpha Vantage data for {symbol}: {str(e)}"

# SEC Filings Tool with Caching
@tool
def get_sec_filings(symbol: str, form_type: str = "10-K") -> str:
    """Get SEC filings data including business description and risk factors.
    
    Args:
        symbol: Stock symbol (e.g., 'AAPL', 'MSFT')
        form_type: SEC form type (e.g., '10-K', '10-Q')
    """
    try:
        # Check cache first
        cached_data = agent_memory.get_cached_data('sec_filings', symbol, form_type=form_type)
        if cached_data:
            return cached_data
        # Dynamic CIK lookup using SEC's company tickers API
        def lookup_cik_online(ticker_symbol):
            """
            Look up CIK (Central Index Key) for a given ticker symbol using SEC's API
            """
            try:
                # SEC company tickers API endpoint
                tickers_url = "https://www.sec.gov/files/company_tickers.json"
                headers = {"User-Agent": "Investment-Research-Agent research@example.com"}
                
                # Add SEC API key to headers if available (for enhanced rate limits or premium services)
                if SEC_API_KEY:
                    headers["Authorization"] = f"Bearer {SEC_API_KEY}"
                    headers["X-API-Key"] = SEC_API_KEY
                
                response = requests.get(tickers_url, headers=headers)
                response.raise_for_status()
                tickers_data = response.json()
                
                # Search for the ticker symbol
                ticker_upper = ticker_symbol.upper()
                for entry in tickers_data.values():
                    if entry.get('ticker', '').upper() == ticker_upper:
                        # Return CIK with proper zero-padding
                        cik_str = str(entry['cik_str']).zfill(10)
                        return cik_str
                
                return None
                
            except Exception as e:
                print(f"Warning: Online CIK lookup failed for {ticker_symbol}: {e}")
                # Fallback to hardcoded lookup for major companies
                fallback_lookup = {
                    "AAPL": "0000320193", "MSFT": "0000789019", "TSLA": "0001318605",
                    "AMZN": "0001018724", "GOOG": "0001652044", "GOOGL": "0001652044",
                    "META": "0001326801", "NVDA": "0001045810", "NFLX": "0001065280",
                    "ADBE": "0000796343", "JPM": "0000019617", "JNJ": "0000200406",
                    "PG": "0000080424", "UNH": "0000731766", "HD": "0000354950"
                }
                return fallback_lookup.get(ticker_symbol.upper())
        
        # Look up CIK dynamically
        print(f"Looking up CIK for {symbol}...")
        cik = lookup_cik_online(symbol)
        if not cik:
            return f"CIK not found for symbol: {symbol}. Please verify the ticker symbol is valid and traded on US exchanges."
        
        # Get filings from SEC EDGAR API
        headers = {"User-Agent": "Investment-Research-Agent research@example.com"}
        
        # Add SEC API key to headers if available (for enhanced rate limits or premium services)
        if SEC_API_KEY:
            headers["Authorization"] = f"Bearer {SEC_API_KEY}"
            headers["X-API-Key"] = SEC_API_KEY
        
        url = f"https://data.sec.gov/submissions/CIK{cik.zfill(10)}.json"
        
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        data = response.json()
        
        # Find most recent filing of requested type
        filings = data.get("filings", {}).get("recent", {})
        filing_info = None
        
        for i in range(len(filings.get("accessionNumber", []))):
            if form_type.upper() in filings["form"][i].upper():
                filing_info = {
                    "form_type": filings["form"][i],
                    "filed_date": filings["filingDate"][i],
                    "report_date": filings["reportDate"][i],
                    "accession_number": filings["accessionNumber"][i],
                    "primary_document": filings["primaryDocument"][i]
                }
                break
        
        if not filing_info:
            return f"No {form_type} filing found for {symbol}"
        
        # Construct filing URL
        accession_clean = filing_info["accession_number"].replace("-", "")
        filing_url = f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{accession_clean}/{filing_info['primary_document']}"
        
        # For now, return filing metadata and URL
        # In a full implementation, you could use SEC-API or similar service to extract specific sections
        result = {
            "symbol": symbol,
            "company_name": data.get("name", "N/A"),
            "cik": cik,
            "latest_filing": {
                "form_type": filing_info["form_type"],
                "filed_date": filing_info["filed_date"],
                "report_date": filing_info["report_date"], 
                "filing_url": filing_url,
                "business_summary": f"Latest {filing_info['form_type']} filing for {symbol}. Contains comprehensive business description, risk factors, and financial statements.",
                "key_sections": [
                    "Item 1: Business Description",
                    "Item 1A: Risk Factors", 
                    "Item 2: Properties",
                    "Item 3: Legal Proceedings",
                    "Financial Statements and Supplementary Data"
                ],
                "investment_relevance": f"This {filing_info['form_type']} filing provides detailed insights into {symbol}'s business model, competitive position, regulatory environment, and material risks that could impact investment returns."
            }
        }
        
        result_json = json.dumps(result, indent=2)
        
        print(f"[DATA] SEC filings retrieved for {symbol} from SEC EDGAR")

        # Cache the result
        agent_memory.cache_data('sec_filings', symbol, result_json, form_type=form_type)
        
        return result_json
        
    except Exception as e:
        return f"Error fetching SEC filings for {symbol}: {str(e)}"

# Investment Recommendation Tool with Caching
@tool
def get_investment_recommendation(symbol: str, analysis_context: str = "") -> str:
    """Generate investment recommendation (Strong Buy, Buy, Hold, Sell, Strong Sell) based on comprehensive analysis.
    
    Args:
        symbol: Stock symbol (e.g., 'AAPL', 'MSFT')
        analysis_context: Optional context from previous analyses to inform recommendation
    """
    try:
        # Check cache first (recommendations have shorter cache time due to market volatility)
        cached_data = agent_memory.get_cached_data('investment_recommendation', symbol, context_hash=hash(analysis_context))
        if cached_data:
            return cached_data
        
        # Gather comprehensive data for recommendation
        print(f"Gathering data for investment recommendation on {symbol}...")
        
        # Get current stock data
        stock_data = get_stock_data.invoke({"symbol": symbol, "period": "6mo"})
        stock_info = json.loads(stock_data) if stock_data.startswith('{') else {}
        
        # Get fundamental data from Alpha Vantage
        alpha_data = get_alpha_vantage_data.invoke({"symbol": symbol, "function": "OVERVIEW"})
        alpha_info = json.loads(alpha_data) if alpha_data.startswith('{') else {}
        
        # Get recent economic context
        economic_data = get_economic_data.invoke({"series_id": "FEDFUNDS"})  # Federal Funds Rate
        econ_info = json.loads(economic_data) if economic_data.startswith('{') else {}
        
        # Calculate recommendation metrics
        recommendation_metrics = {
            'symbol': symbol,
            'current_price': stock_info.get('current_price', 0),
            'price_change_pct': stock_info.get('price_change_pct', 0),
            'pe_ratio': alpha_info.get('pe_ratio', 'N/A'),
            'peg_ratio': alpha_info.get('peg_ratio', 'N/A'),
            'dividend_yield': alpha_info.get('dividend_yield', 'N/A'),
            'market_cap': alpha_info.get('market_cap', 'N/A'),
            '52_week_high': alpha_info.get('52_week_high', stock_info.get('high_52_week', 0)),
            '52_week_low': alpha_info.get('52_week_low', stock_info.get('low_52_week', 0)),
            'volume': stock_info.get('volume', 0),
            'avg_volume': stock_info.get('avg_volume', 0),
            'sector': stock_info.get('sector', 'N/A'),
            'federal_funds_rate': econ_info.get('latest_value', 'N/A')
        }
        
        # Calculate recommendation score (0-100 scale)
        score = 50  # Start neutral
        confidence_factors = []
        
        # Price momentum analysis
        price_change = recommendation_metrics['price_change_pct']
        if price_change > 5:
            score += 10
            confidence_factors.append("Strong positive price momentum")
        elif price_change > 2:
            score += 5
            confidence_factors.append("Positive price momentum")
        elif price_change < -5:
            score -= 10
            confidence_factors.append("Negative price momentum")
        elif price_change < -2:
            score -= 5
            confidence_factors.append("Weak price momentum")
        
        # Valuation analysis
        try:
            pe_ratio = float(alpha_info.get('pe_ratio', 0)) if alpha_info.get('pe_ratio', 'N/A') != 'N/A' else None
            if pe_ratio:
                if pe_ratio < 15:
                    score += 8
                    confidence_factors.append("Attractive P/E valuation")
                elif pe_ratio < 25:
                    score += 3
                    confidence_factors.append("Reasonable P/E valuation")
                elif pe_ratio > 40:
                    score -= 8
                    confidence_factors.append("High P/E valuation concern")
        except:
            pass
        
        # Volume analysis
        current_volume = recommendation_metrics['volume']
        avg_volume = recommendation_metrics['avg_volume']
        if avg_volume > 0:
            volume_ratio = current_volume / avg_volume
            if volume_ratio > 1.5:
                score += 5
                confidence_factors.append("High trading volume indicates interest")
            elif volume_ratio < 0.5:
                score -= 3
                confidence_factors.append("Low volume may indicate lack of interest")
        
        # 52-week range analysis
        current_price = recommendation_metrics['current_price']
        week_52_high = float(recommendation_metrics['52_week_high']) if recommendation_metrics['52_week_high'] else current_price
        week_52_low = float(recommendation_metrics['52_week_low']) if recommendation_metrics['52_week_low'] else current_price
        
        if week_52_high > week_52_low:
            price_position = (current_price - week_52_low) / (week_52_high - week_52_low)
            if price_position < 0.3:
                score += 7
                confidence_factors.append("Trading near 52-week low - potential upside")
            elif price_position > 0.8:
                score -= 5
                confidence_factors.append("Trading near 52-week high - limited upside")
        
        # Economic environment factor
        try:
            fed_rate = float(econ_info.get('latest_value', 0))
            if fed_rate > 5:
                score -= 5
                confidence_factors.append("High interest rates headwind")
            elif fed_rate < 2:
                score += 3
                confidence_factors.append("Low interest rates supportive")
        except:
            pass
        
        # Determine recommendation based on score
        if score >= 75:
            recommendation = "Strong Buy"
            confidence = "High"
        elif score >= 60:
            recommendation = "Buy" 
            confidence = "High" if score >= 65 else "Medium"
        elif score >= 40:
            recommendation = "Hold"
            confidence = "Medium"
        elif score >= 25:
            recommendation = "Sell"
            confidence = "Medium" if score >= 30 else "High"
        else:
            recommendation = "Strong Sell"
            confidence = "High"
        
        # Calculate target price estimate
        target_price = current_price
        if recommendation in ["Strong Buy", "Buy"]:
            target_price = current_price * (1 + (score - 50) / 200)
        elif recommendation in ["Sell", "Strong Sell"]:
            target_price = current_price * (1 - (50 - score) / 200)
        
        # Prepare recommendation result
        result = {
            'symbol': symbol,
            'recommendation': recommendation,
            'confidence': confidence,
            'recommendation_score': round(score, 1),
            'current_price': current_price,
            'target_price': round(target_price, 2),
            'price_target_change_pct': round(((target_price - current_price) / current_price) * 100, 2),
            'analysis_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            'key_factors': confidence_factors[:5],  # Top 5 factors
            'risk_level': 'High' if abs(score - 50) > 25 else 'Medium' if abs(score - 50) > 15 else 'Low',
            'investment_horizon': '3-6 months',
            'metrics_analyzed': recommendation_metrics,
            'analysis_context': analysis_context[:500] if analysis_context else "Standalone recommendation analysis"
        }
        
        result_json = json.dumps(result, indent=2)
        
        print(f"[DATA] Investment recommendation generated for {symbol}")
        
        # Cache the result (shorter cache for recommendations due to volatility)
        agent_memory.cache_data('investment_recommendation', symbol, result_json, context_hash=hash(analysis_context))
        
        return result_json
        
    except Exception as e:
        return f"Error generating investment recommendation for {symbol}: {str(e)}"

print("[SYSTEM] Data source tools created successfully")

[SYSTEM] Data source tools created successfully

class PromptConfiguration:
    """Central configuration class for all prompts used in the investment research system"""
    
    @staticmethod
    def get_planning_prompt(role: str, task: str) -> str:
        return f"""
        As an {role}, create a detailed research plan for: {task}
        
        Consider these aspects:
        1. Data gathering (price data, news, economic indicators, fundamentals)
        2. Analysis techniques (technical, fundamental, sentiment)
        3. Risk assessment
        4. Market context evaluation
        
        Return a numbered list of specific, actionable research steps.
        """
    
    @staticmethod
    def get_reflection_prompt(analysis_result: str) -> str:
        return f"""
        Please evaluate this investment analysis for quality and completeness:
        
        Analysis: {analysis_result}
        
        Provide a structured evaluation covering:
        1. Completeness (1-10): Are all key aspects covered?
        2. Data Quality (1-10): Is the data comprehensive and current?
        3. Logic (1-10): Is the reasoning sound and well-structured?
        4. Actionability (1-10): Are the conclusions practical and specific?
        5. Risk Assessment (1-10): Are risks properly identified and evaluated?
        
        Also provide:
        - Overall Score (1-10)
        - Key Strengths (2-3 points)
        - Areas for Improvement (2-3 points)
        - Specific Recommendations for enhancement
        
        Format as JSON with these exact keys: completeness, data_quality, logic, actionability, risk_assessment, overall_score, strengths, improvements, recommendations
        """
    
    @staticmethod
    def get_news_classification_prompt(title: str, description: str) -> str:
        return f"""
        Classify this news article:
        Title: {title}
        Description: {description}
        
        Provide classification in JSON format:
        {{
            "category": "earnings|product|market|regulation|management|merger|other",
            "sentiment": "positive|negative|neutral",
            "importance": "high|medium|low",
            "reasoning": "brief explanation"
        }}
        """
    
    @staticmethod
    def get_insights_extraction_prompt(classified_articles: str) -> str:
        return f"""
        Extract key insights from these classified news articles:
        
        {classified_articles}
        
        Provide insights in JSON format:
        {{
            "key_themes": ["list of main themes"],
            "sentiment_distribution": {{"positive": 0, "negative": 0, "neutral": 0}},
            "high_importance_items": ["list of high importance findings"],
            "potential_catalysts": ["events that could drive stock price"],
            "risk_factors": ["identified risks or concerns"]
        }}
        """
    
    @staticmethod
    def get_news_summarization_prompt(insights: str, symbol: str) -> str:
        return f"""
        Create a comprehensive news analysis summary for {symbol} based on these insights:
        
        {insights}
        
        Provide a professional investment-focused summary covering:
        1. Executive Summary (2-3 sentences)
        2. Key Developments and Themes
        3. Sentiment Analysis
        4. Potential Stock Price Catalysts
        5. Risk Factors and Concerns
        6. Investment Implications
        
        Keep the analysis concise but comprehensive, suitable for investment decision-making.
        """
    
    @staticmethod 
    def get_technical_analysis_prompt(symbol: str, stock_data: str) -> str:
        return f"""
        Conduct technical analysis for {symbol} based on this stock data:
        
        {stock_data}
        
        Provide analysis covering:
        1. Price trends and patterns
        2. Volume analysis  
        3. Support and resistance levels
        4. Technical indicators (if calculable from data)
        5. Short-term price outlook
        6. Key technical levels to watch
        
        Format as a professional technical analysis suitable for investment decisions.
        """
    
    @staticmethod
    def get_fundamental_analysis_prompt(symbol: str, stock_data: str, alpha_overview: str) -> str:
        return f"""
        Conduct fundamental analysis for {symbol} based on this data:
        
        Stock Data: {stock_data}
        Company Overview: {alpha_overview}
        
        Provide analysis covering:
        1. Financial health assessment
        2. Valuation metrics analysis
        3. Business model evaluation
        4. Competitive position
        5. Growth prospects
        6. Risk factors
        7. Fair value estimate
        
        Format as a professional fundamental analysis suitable for investment decisions.
        """
    
    @staticmethod
    def get_sentiment_analysis_prompt(symbol: str, news_analysis: str) -> str:
        return f"""
        Enhance this news analysis for {symbol} with sentiment insights:
        
        News Analysis: {news_analysis}
        
        Provide enhanced analysis focusing on:
        1. Overall sentiment assessment
        2. Market perception trends
        3. Potential impact on stock price
        4. Investor sentiment drivers
        5. Sentiment-based risks and opportunities
        
        Format as professional sentiment analysis for investment decisions.
        """
    
    @staticmethod
    def get_sec_filings_analysis_prompt(symbol: str, sec_data: str) -> str:
        return f"""
        Analyze SEC filings for {symbol} based on this data:
        
        SEC Data: {sec_data}
        
        Provide analysis covering:
        1. Key regulatory disclosures
        2. Risk factor analysis
        3. Management discussion insights
        4. Financial statement highlights
        5. Compliance and governance assessment
        6. Material changes or events
        
        Format as professional regulatory analysis for investment decisions.
        """
    
    @staticmethod
    def get_investment_recommendation_prompt(symbol: str, recommendation_data: str, analysis_context: str) -> str:
        return f"""
        Generate investment recommendation for {symbol} based on:
        
        Recommendation Data: {recommendation_data}
        Analysis Context: {analysis_context}
        
        Provide comprehensive recommendation covering:
        1. Investment thesis
        2. Recommendation (Buy/Hold/Sell) with rationale
        3. Price target and timeline
        4. Risk assessment
        5. Portfolio allocation suggestions
        6. Key catalysts and monitoring points
        
        Format as professional investment recommendation suitable for decision-making.
        """
    
    @staticmethod
    def get_routing_prompt(request: str, symbol: str) -> str:
        return f"""
        Route this investment research request for {symbol}: {request}
        
        Available specialists:
        - technical: Technical analysis (price trends, indicators, charts)
        - fundamental: Fundamental analysis (financials, valuation, business)
        - news: News and sentiment analysis
        - sec: SEC filings and regulatory analysis
        - recommendation: Investment recommendation synthesis
        
        Respond in JSON format:
        {{
            "specialists_needed": ["list of specialist types needed"],
            "priority_order": ["order of execution"],
            "reasoning": "explanation of routing decision"
        }}
        """
    
    @staticmethod
    def get_evaluation_prompt(analysis: str, symbol: str) -> str:
        return f"""
        As an Investment Analysis Quality Evaluator, assess this investment analysis for {symbol}:
        
        Analysis:
        {analysis}
        
        Evaluate on these criteria (1-10 scale):
        1. Completeness: Are all key investment aspects covered?
        2. Data Integration: How well are different data sources synthesized?
        3. Risk Assessment: Is risk analysis comprehensive and realistic?
        4. Actionability: Are recommendations specific and implementable?
        5. Logic and Reasoning: Is the analysis logical and well-structured?
        6. Market Context: Is broader market context considered?
        7. Clarity: Is the analysis clear and professional?
        
        Provide feedback in JSON format:
        {{
            "scores": {{
                "completeness": X,
                "data_integration": X,
                "risk_assessment": X,
                "actionability": X,
                "logic_reasoning": X,
                "market_context": X,
                "clarity": X
            }},
            "overall_score": X,
            "grade": "A|B|C|D|F",
            "strengths": ["list of key strengths"],
            "weaknesses": ["list of areas needing improvement"],
            "specific_improvements": ["detailed suggestions for enhancement"],
            "missing_elements": ["what's missing from the analysis"]
        }}
        """
    
    @staticmethod
    def get_refinement_prompt(original_analysis: str, evaluation: str, symbol: str) -> str:
        return f"""
        Improve this investment analysis for {symbol} based on the evaluation feedback:
        
        Original Analysis:
        {original_analysis}
        
        Evaluation Feedback:
        {evaluation}
        
        Create an improved version that addresses these issues:
        1. Fix identified weaknesses
        2. Add missing elements
        3. Implement specific improvements
        4. Enhance overall quality and completeness
        5. Maintain professional investment analysis standards
        
        Focus particularly on areas that scored below 7/10 in the evaluation.
        """
    
    @staticmethod
    def get_specialist_summary_prompt(specialist_type: str, analysis_content: str, symbol: str, focus_areas: list, output_format: str) -> str:
        return f"""
        Create an executive-level summary of this {specialist_type} analysis for {symbol}.
        
        Original Analysis:
        {analysis_content[:2000]}
        
        Focus on these key areas: {', '.join(focus_areas)}
        
        Provide a concise summary in this format:
        {output_format}
        
        Requirements:
        - Maximum 150 words
        - Use bullet points for key findings
        - Include specific metrics and actionable insights
        - Clear, professional investment language
        - Highlight the most critical information for decision-making
        
        Format as:

        **Key Findings**:
        - [Key finding 1]
        - [Key finding 2]
        - [Key finding 3]
        
        **Bottom Line:** [One sentence conclusion]
        """
    
    @staticmethod
    def get_executive_summary_prompt(combined_summaries: str, symbol: str) -> str:
        return f"""
        Create an executive summary for {symbol} investment decision based on these specialist summaries:
        
        {combined_summaries}
        
        Provide a comprehensive executive summary in this format:
        
        **Investment Thesis:** [2-3 sentences on overall investment attractiveness]
        
        **Key Strengths:**
        - [Top 3 positive factors]
        
        **Key Risks:**
        - [Top 3 risk factors]
        
        **Recommendation:** [Clear buy/sell/hold with rationale]
        
        **Price Target & Timeline:** [If available from recommendation analysis]
        
        **Risk Level:** [High/Medium/Low with justification]
        
        Requirements:
        - Maximum 200 words total
        - Synthesize insights across all analyses
        - Provide clear, actionable investment guidance
        - Balance technical, fundamental, and sentiment factors
        - Professional investment committee presentation style
        """

print("[SYSTEM] Prompt configuration class created")

[SYSTEM] Prompt configuration class created

class InvestmentResearchAgent:
    """Base Investment Research Agent with planning, tool usage, self-reflection, and learning capabilities."""
    
    def __init__(self, name: str, role: str, memory: AgentMemory):
        self.name = name
        self.role = role
        self.memory = memory
        self.llm = llm
        self.session_memory = ConversationBufferWindowMemory(
            k=10, 
            memory_key="chat_history", 
            return_messages=True
        )
        self.tools = [get_stock_data, get_stock_news, get_economic_data, get_alpha_vantage_data, get_sec_filings, get_investment_recommendation]
        self.execution_log = []
    
    def invoke_llm_with_logging(self, prompt: str, context: str = "") -> tuple:
        """Invoke LLM and log the model information along with response"""
        try:
            response = self.llm.invoke([HumanMessage(content=prompt)])
            
            # Extract model information
            # Extract model information
            model_name = getattr(response, 'response_metadata', {}).get('model_name', 'Unknown')
            if not model_name or model_name == 'Unknown':
                # Try to get model from LLM configuration
                model_name = getattr(self.llm, 'deployment_name', getattr(self.llm, 'model_name', 'Azure OpenAI Model'))
            
            # Get token count information
            token_count = 'N/A'
            if hasattr(response, 'usage_metadata') and response.usage_metadata:
                token_count = response.usage_metadata.get('total_tokens', 'N/A')
            elif hasattr(response, 'response_metadata') and response.response_metadata:
                usage = response.response_metadata.get('token_usage', {})
                if usage:
                    token_count = usage.get('total_tokens', 'N/A')
            
            # Print model information with token count
            print(f"[AGENT] Model: {model_name} | Tokens: {token_count} | Context: {context}")

            return response.content, model_name
            
        except Exception as e:
            print(f"LLM Error in {context}: {e}")
            return f"Error in LLM call: {str(e)}", "Error"
        
    def plan_research(self, task: str) -> List[str]:
        """Plan research steps for a given task."""
        planning_prompt = PromptConfiguration.get_planning_prompt(self.role, task)
        
        try:
            plan_text, model_name = self.invoke_llm_with_logging(planning_prompt, f"{self.name} - Research Planning")
            
            # Extract numbered steps
            steps = []
            for line in plan_text.split('\n'):
                line = line.strip()
                if line and (line[0].isdigit() or line.startswith('-') or line.startswith('*')):
                    steps.append(line)
            
            # Log the plan
            self.execution_log.append({
                'timestamp': datetime.now().isoformat(),
                'action': 'plan_created',
                'task': task,
                'plan': steps,
                'model_used': model_name
            })
            
            return steps
        
        except Exception as e:
            print(f"Error in planning: {e}")
            return ["1. Gather basic stock data", "2. Analyze recent news", "3. Review economic context", "4. Synthesize findings"]
    
    def use_tool_dynamically(self, tool_name: str, **kwargs) -> str:
        """Use tools dynamically based on context."""
        tool_map = {
            'stock_data': get_stock_data,
            'news': get_stock_news,
            'economic': get_economic_data,
            'alpha_vantage': get_alpha_vantage_data,
            'sec_filings': get_sec_filings
        }
        
        try:
            if tool_name in tool_map:
                result = tool_map[tool_name].invoke(kwargs)
                
                # Log tool usage
                self.execution_log.append({
                    'timestamp': datetime.now().isoformat(),
                    'action': 'tool_used',
                    'tool': tool_name,
                    'parameters': kwargs,
                    'success': True
                })
                
                return result
            else:
                return f"Tool '{tool_name}' not available"
        
        except Exception as e:
            self.execution_log.append({
                'timestamp': datetime.now().isoformat(),
                'action': 'tool_used',
                'tool': tool_name,
                'parameters': kwargs,
                'success': False,
                'error': str(e)
            })
            return f"Error using tool '{tool_name}': {str(e)}"
    
    def self_reflect(self, analysis_result: str) -> Dict[str, Any]:
        """Self-reflect on the quality of analysis output."""
        reflection_prompt = PromptConfiguration.get_reflection_prompt(analysis_result)
        
        try:
            reflection_text, model_name = self.invoke_llm_with_logging(reflection_prompt, f"{self.name} - Self Reflection")
            
            # Try to parse as JSON, fallback to structured text parsing
            try:
                reflection_data = json.loads(reflection_text)
            except:
                # Fallback parsing
                reflection_data = {
                    'overall_score': 7,
                    'strengths': ["Analysis provided"],
                    'improvements': ["Could be more detailed"],
                    'recommendations': ["Gather more data points"]
                }
            
            # Log reflection
            self.execution_log.append({
                'timestamp': datetime.now().isoformat(),
                'action': 'self_reflection',
                'reflection': reflection_data,
                'model_used': model_name
            })
            
            return reflection_data
        
        except Exception as e:
            print(f"Error in self-reflection: {e}")
            return {
                'overall_score': 5,
                'strengths': ["Attempt made"],
                'improvements': ["Technical issues encountered"],
                'recommendations': ["Retry analysis"]
            }
    
    def learn_from_experience(self, task: str, result: str, reflection: Dict[str, Any]):
        """Learn from the current analysis and store insights for future use."""
        try:
            # Create learning content
            learning_content = f"""
            Task: {task}
            Analysis Quality Score: {reflection.get('overall_score', 'N/A')}
            Key Insights: {', '.join(reflection.get('strengths', []))}
            Improvement Areas: {', '.join(reflection.get('improvements', []))}
            Recommendations: {', '.join(reflection.get('recommendations', []))}
            Execution Log: {len(self.execution_log)} actions taken
            """
            
            # Store in memory
            metadata = {
                'type': 'learning_experience',
                'agent': self.name,
                'task': task,
                'timestamp': datetime.now().isoformat(),
                'quality_score': reflection.get('overall_score', 0)
            }
            
            self.memory.add_memory(learning_content, metadata)
            
            print(f"{self.name} learned from experience (Score: {reflection.get('overall_score', 'N/A')})")
        
        except Exception as e:
            print(f"Error in learning: {e}")
    
    def retrieve_relevant_experience(self, task: str) -> List[str]:
        """Retrieve relevant past experiences for the current task."""
        try:
            memories = self.memory.search_memory(task, k=3)
            experiences = []
            
            for memory in memories:
                if memory.metadata.get('type') == 'learning_experience':
                    experiences.append(memory.page_content)
            
            return experiences
        
        except Exception as e:
            print(f"Error retrieving experience: {e}")
            return []

print("[SYSTEM] Base Investment Research Agent class created")

[SYSTEM] Base Investment Research Agent class created

class NewsProcessingChain:
    """Implements Prompt Chaining: Ingest → Preprocess → Classify → Extract → Summarize"""
    
    def __init__(self, llm):
        self.llm = llm
    
    def invoke_llm_with_logging(self, prompt: str, context: str = "") -> tuple:
        """Invoke LLM and log the model information along with response"""
        try:
            response = self.llm.invoke([HumanMessage(content=prompt)])
            
            # Extract model information
            model_name = getattr(response, 'response_metadata', {}).get('model_name', 'Unknown')
            if not model_name or model_name == 'Unknown':
                # Try to get model from LLM configuration
                model_name = getattr(self.llm, 'deployment_name', getattr(self.llm, 'model_name', 'Azure OpenAI Model'))
            
            # Get token count information
            token_count = 'N/A'
            if hasattr(response, 'usage_metadata') and response.usage_metadata:
                token_count = response.usage_metadata.get('total_tokens', 'N/A')
            elif hasattr(response, 'response_metadata') and response.response_metadata:
                usage = response.response_metadata.get('token_usage', {})
                if usage:
                    token_count = usage.get('total_tokens', 'N/A')
            
            # Print model information
            print(f"[NEWS CHAIN] Model: {model_name} | Tokens: {token_count} | Context: {context}")

            return response.content, model_name
            
        except Exception as e:
            print(f"LLM Error in {context}: {e}")
            return f"Error in LLM call: {str(e)}", "Error"
    
    def ingest_news(self, symbol: str) -> List[Dict]:
        """Step 1: Ingest news data"""
        try:
            news_data = get_stock_news.invoke({"symbol": symbol, "days": 7})
            
            # Handle empty or None response
            if not news_data or news_data.strip() == "":
                print(f"No news data returned for {symbol}")
                return []
            
            # Check if response is an error message (string starting with "Error")
            if isinstance(news_data, str) and news_data.startswith("Error"):
                print(f"News API error: {news_data}")
                return []
            
            # Try to parse JSON
            try:
                parsed_data = json.loads(news_data)
                
                # Handle different response formats
                if isinstance(parsed_data, list):
                    return parsed_data
                elif isinstance(parsed_data, dict):
                    # If it's a dict with news items, extract them
                    if 'news' in parsed_data:
                        return parsed_data['news']
                    elif 'articles' in parsed_data:
                        return parsed_data['articles']
                    else:
                        # Return as single item list
                        return [parsed_data]
                else:
                    print(f"Unexpected news data format: {type(parsed_data)}")
                    return []
                    
            except json.JSONDecodeError as je:
                print(f"JSON parsing error: {je}")
                print(f"Raw response: {news_data[:200]}...")  # Show first 200 chars
                return []
                
        except Exception as e:
            print(f"Error ingesting news: {e}")
            return []
    
    def preprocess_news(self, news_articles: List[Dict]) -> List[Dict]:
        """Step 2: Preprocess and clean news articles"""
        processed_articles = []
        
        for article in news_articles:
            # Clean and structure the article
            processed_article = {
                'title': article.get('title', '').strip(),
                'description': article.get('description', '').strip(),
                'source': article.get('source', 'Unknown'),
                'published_at': article.get('published_at', ''),
                'url': article.get('url', ''),
                'combined_text': f"{article.get('title', '')} {article.get('description', '')}".strip()
            }
            
            # Only include articles with meaningful content
            if processed_article['combined_text'] and len(processed_article['combined_text']) > 20:
                processed_articles.append(processed_article)
        
        return processed_articles
    
    def classify_news(self, processed_articles: List[Dict]) -> List[Dict]:
        """Step 3: Classify news articles by type and sentiment"""
        classified_articles = []
        
        for article in processed_articles:
            classify_prompt = PromptConfiguration.get_news_classification_prompt(
                article['title'], 
                article['description']
            )
            
            try:
                classification_text, model_name = self.invoke_llm_with_logging(
                    classify_prompt, 
                    "News Classification"
                )
                
                # Try to parse JSON, fallback to default values
                try:
                    classification = json.loads(classification_text)
                except:
                    classification = {
                        "category": "other",
                        "sentiment": "neutral",
                        "importance": "medium",
                        "reasoning": "Classification parsing failed"
                    }
                
                article.update(classification)
                article['model_used'] = model_name
                classified_articles.append(article)
            
            except Exception as e:
                print(f"Error classifying article: {e}")
                article.update({
                    "category": "other",
                    "sentiment": "neutral",
                    "importance": "medium",
                    "reasoning": "Error in classification",
                    "model_used": "Error"
                })
                classified_articles.append(article)
        
        return classified_articles
    
    def extract_insights(self, classified_articles: List[Dict]) -> Dict[str, Any]:
        """Step 4: Extract key insights from classified articles"""
        classified_articles_str = json.dumps(classified_articles, indent=2)[:2000]  # Truncate to avoid token limits
        insights_prompt = PromptConfiguration.get_insights_extraction_prompt(classified_articles_str)
        
        try:
            insights_text, model_name = self.invoke_llm_with_logging(
                insights_prompt, 
                "Insights Extraction"
            )
            
            try:
                insights = json.loads(insights_text)
                insights['model_used'] = model_name
            except:
                # Fallback insights
                sentiment_counts = {"positive": 0, "negative": 0, "neutral": 0}
                for article in classified_articles:
                    sentiment = article.get('sentiment', 'neutral')
                    sentiment_counts[sentiment] += 1
                
                insights = {
                    "key_themes": ["General market activity"],
                    "sentiment_distribution": sentiment_counts,
                    "high_importance_items": [item['title'] for item in classified_articles if item.get('importance') == 'high'],
                    "potential_catalysts": ["Market developments"],
                    "risk_factors": ["Market volatility"],
                    "model_used": model_name
                }
            
            return insights
        
        except Exception as e:
            print(f"Error extracting insights: {e}")
            return {
                "key_themes": ["Analysis error"],
                "sentiment_distribution": {"positive": 0, "negative": 0, "neutral": len(classified_articles)},
                "high_importance_items": [],
                "potential_catalysts": [],
                "risk_factors": ["Analysis uncertainty"],
                "model_used": "Error"
            }
    
    def summarize_analysis(self, insights: Dict[str, Any], symbol: str) -> str:
        """Step 5: Summarize the complete news analysis"""
        insights_str = json.dumps(insights, indent=2)
        summarize_prompt = PromptConfiguration.get_news_summarization_prompt(insights_str, symbol)
        
        try:
            summary, model_name = self.invoke_llm_with_logging(
                summarize_prompt, 
                f"News Summary for {symbol}"
            )
            return summary
        
        except Exception as e:
            print(f"Error in summarization: {e}")
            return f"News analysis for {symbol} completed with {len(insights.get('key_themes', []))} key themes identified. Sentiment distribution shows mixed signals. Further analysis recommended."
    
    def process_news_chain(self, symbol: str) -> Dict[str, Any]:
        """Execute the complete news processing chain"""
        print(f"[NEWS CHAIN] Initiating processing pipeline | Symbol: {symbol}")
        
        # Step 1: Ingest
        print("[NEWS CHAIN] Step 1: News ingestion")
        raw_news = self.ingest_news(symbol)
        
        # Step 2: Preprocess
        print("[NEWS CHAIN] Step 2: News preprocessing")
        processed_news = self.preprocess_news(raw_news)
        
        # Step 3: Classify
        print("[NEWS CHAIN] Step 3: News classification")
        classified_news = self.classify_news(processed_news)
        
        # Step 4: Extract
        print("[NEWS CHAIN] Step 4: Insight extraction")
        insights = self.extract_insights(classified_news)
        
        # Step 5: Summarize
        print("[NEWS CHAIN] Step 5: Summary generation")
        summary = self.summarize_analysis(insights, symbol)
        
        return {
            'symbol': symbol,
            'raw_articles_count': len(raw_news),
            'processed_articles_count': len(processed_news),
            'classified_articles': classified_news,
            'insights': insights,
            'summary': summary,
            'timestamp': datetime.now().isoformat()
        }

# Initialize news processing chain
news_chain = NewsProcessingChain(llm)
print("[SYSTEM] News Processing Chain (Prompt Chaining) created")

[SYSTEM] News Processing Chain (Prompt Chaining) created

class SpecialistAgent(InvestmentResearchAgent):
    """Base class for specialist agents"""
    
    def __init__(self, name: str, role: str, specialization: str, memory: AgentMemory):
        super().__init__(name, role, memory)
        self.specialization = specialization
    
    def analyze(self, data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Perform specialized analysis - to be implemented by subclasses"""
        raise NotImplementedError

class TechnicalAnalyst(SpecialistAgent):
    """Specialist agent for technical analysis"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("TechnicalAnalyst", "Technical Analysis Specialist", "technical_analysis", memory)
    
    def analyze(self, data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Perform technical analysis with caching"""
        try:
            # Generate request hash for caching
            import hashlib
            request_hash = hashlib.md5(f"technical_{symbol}_6mo".encode()).hexdigest()
            
            # Check for cached analysis first
            cached_analysis = self.memory.get_cached_analysis('technical', symbol, request_hash)
            if cached_analysis:
                return cached_analysis
            
            # Get stock data for technical analysis
            stock_data = self.use_tool_dynamically('stock_data', symbol=symbol, period='6mo')
            
            technical_prompt = PromptConfiguration.get_technical_analysis_prompt(symbol, stock_data)
            
            analysis, model_name = self.invoke_llm_with_logging(
                technical_prompt, 
                f"Technical Analysis for {symbol}"
            )
            
            result = {
                'specialist': self.name,
                'analysis_type': 'technical',
                'symbol': symbol,
                'analysis': analysis,
                'timestamp': datetime.now().isoformat(),
                'data_used': ['stock_price_data', 'volume_data'],
                'model_used': model_name
            }
            
            # Cache the analysis result
            self.memory.cache_analysis('technical', symbol, result, request_hash)
            
            return result
        
        except Exception as e:
            return {
                'specialist': self.name,
                'analysis_type': 'technical',
                'symbol': symbol,
                'analysis': f"Technical analysis error: {str(e)}",
                'timestamp': datetime.now().isoformat(),
                'error': True,
                'model_used': 'Error'
            }

class FundamentalAnalyst(SpecialistAgent):
    """Specialist agent for fundamental analysis"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("FundamentalAnalyst", "Fundamental Analysis Specialist", "fundamental_analysis", memory)
    
    def analyze(self, data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Perform fundamental analysis with caching"""
        try:
            # Generate request hash for caching
            import hashlib
            request_hash = hashlib.md5(f"fundamental_{symbol}_overview".encode()).hexdigest()
            
            # Check for cached analysis first
            cached_analysis = self.memory.get_cached_analysis('fundamental', symbol, request_hash)
            if cached_analysis:
                return cached_analysis
            
            # Get fundamental data
            stock_data = self.use_tool_dynamically('stock_data', symbol=symbol)
            alpha_overview = self.use_tool_dynamically('alpha_vantage', symbol=symbol, function='OVERVIEW')
            
            fundamental_prompt = PromptConfiguration.get_fundamental_analysis_prompt(symbol, stock_data, alpha_overview)
            
            analysis, model_name = self.invoke_llm_with_logging(
                fundamental_prompt, 
                f"Fundamental Analysis for {symbol}"
            )
            
            result = {
                'specialist': self.name,
                'analysis_type': 'fundamental',
                'symbol': symbol,
                'analysis': analysis,
                'timestamp': datetime.now().isoformat(),
                'data_used': ['company_financials', 'market_data', 'ratios'],
                'model_used': model_name
            }
            
            # Cache the analysis result
            self.memory.cache_analysis('fundamental', symbol, result, request_hash)
            
            return result
        
        except Exception as e:
            return {
                'specialist': self.name,
                'analysis_type': 'fundamental',
                'symbol': symbol,
                'analysis': f"Fundamental analysis error: {str(e)}",
                'timestamp': datetime.now().isoformat(),
                'error': True,
                'model_used': 'Error'
            }

class NewsAnalyst(SpecialistAgent):
    """Specialist agent for news and sentiment analysis"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("NewsAnalyst", "News and Sentiment Analysis Specialist", "news_analysis", memory)
    
    def analyze(self, data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Perform news and sentiment analysis"""
        try:
            # Use the news processing chain
            news_analysis = news_chain.process_news_chain(symbol)
            
            news_analysis_str = json.dumps(news_analysis, indent=2)[:1500]
            sentiment_prompt = PromptConfiguration.get_sentiment_analysis_prompt(symbol, news_analysis_str)
            
            enhanced_analysis, model_name = self.invoke_llm_with_logging(
                sentiment_prompt, 
                f"Sentiment Analysis for {symbol}"
            )
            
            return {
                'specialist': self.name,
                'analysis_type': 'news_sentiment',
                'symbol': symbol,
                'analysis': enhanced_analysis,
                'raw_news_analysis': news_analysis,
                'timestamp': datetime.now().isoformat(),
                'data_used': ['news_articles', 'sentiment_data'],
                'model_used': model_name
            }
        
        except Exception as e:
            return {
                'specialist': self.name,
                'analysis_type': 'news_sentiment',
                'symbol': symbol,
                'analysis': f"News analysis error: {str(e)}",
                'timestamp': datetime.now().isoformat(),
                'error': True,
                'model_used': 'Error'
            }

class SECFilingsAnalyst(SpecialistAgent):
    """Specialist agent for SEC filings and regulatory analysis"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("SECFilingsAnalyst", "SEC Filings and Regulatory Analysis Specialist", "sec_analysis", memory)
    
    def analyze(self, data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Perform SEC filings analysis"""
        try:
            # Get SEC filings data
            sec_data = self.use_tool_dynamically('get_sec_filings', symbol=symbol)
            
            sec_analysis_str = json.dumps(sec_data, indent=2)[:2000]
            sec_prompt = PromptConfiguration.get_sec_filings_analysis_prompt(symbol, sec_analysis_str)
            
            analysis, model_name = self.invoke_llm_with_logging(
                sec_prompt, 
                f"SEC Filings Analysis for {symbol}"
            )
            
            return {
                'specialist': self.name,
                'analysis_type': 'sec_filings',
                'symbol': symbol,
                'analysis': analysis,
                'raw_sec_data': sec_data,
                'timestamp': datetime.now().isoformat(),
                'data_used': ['sec_filings', 'regulatory_data', 'risk_factors'],
                'model_used': model_name
            }
        
        except Exception as e:
            return {
                'specialist': self.name,
                'analysis_type': 'sec_filings',
                'symbol': symbol,
                'analysis': f"SEC filings analysis error: {str(e)}",
                'timestamp': datetime.now().isoformat(),
                'error': True,
                'model_used': 'Error'
            }

class InvestmentRecommendationAnalyst(SpecialistAgent):
    """Specialist agent for investment recommendations"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("InvestmentRecommendationAnalyst", "Investment Recommendation Specialist", "recommendation_analysis", memory)
    
    def analyze(self, data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Perform investment recommendation analysis with caching"""
        try:
            # Generate request hash for caching
            import hashlib
            request_hash = hashlib.md5(f"recommendation_{symbol}_comprehensive".encode()).hexdigest()
            
            # Check for cached analysis first
            cached_analysis = self.memory.get_cached_analysis('recommendation', symbol, request_hash)
            if cached_analysis:
                return cached_analysis
            
            # Get comprehensive data for recommendation
            analysis_context = ""
            if data.get('specialist_analyses'):
                # Use other specialist analyses as context
                context_parts = []
                for spec_type, spec_analysis in data['specialist_analyses'].items():
                    if spec_analysis.get('analysis'):
                        context_parts.append(f"{spec_type}: {spec_analysis['analysis'][:200]}...")
                analysis_context = " | ".join(context_parts)
            
            # Get investment recommendation using the tool
            recommendation_data = self.use_tool_dynamically('get_investment_recommendation', symbol=symbol, analysis_context=analysis_context)
            
            # Parse the recommendation data
            try:
                recommendation_info = json.loads(recommendation_data)
            except:
                recommendation_info = {"error": "Failed to parse recommendation data"}
            
            # Generate detailed analysis using the recommendation prompt
            recommendation_prompt = PromptConfiguration.get_investment_recommendation_prompt(symbol, recommendation_data, analysis_context)
            
            detailed_analysis, model_name = self.invoke_llm_with_logging(
                recommendation_prompt, 
                f"Investment Recommendation for {symbol}"
            )
            
            result = {
                'specialist': self.name,
                'analysis_type': 'investment_recommendation',
                'symbol': symbol,
                'analysis': detailed_analysis,
                'recommendation_data': recommendation_info,
                'recommendation': recommendation_info.get('recommendation', 'Hold'),
                'confidence': recommendation_info.get('confidence', 'Medium'),
                'target_price': recommendation_info.get('target_price', 0),
                'current_price': recommendation_info.get('current_price', 0),
                'price_target_change_pct': recommendation_info.get('price_target_change_pct', 0),
                'risk_level': recommendation_info.get('risk_level', 'Medium'),
                'timestamp': datetime.now().isoformat(),
                'data_used': ['comprehensive_analysis', 'price_data', 'valuation_metrics', 'economic_indicators'],
                'model_used': model_name
            }
            
            # Cache the analysis result
            self.memory.cache_analysis('recommendation', symbol, result, request_hash)
            
            return result
        
        except Exception as e:
            return {
                'specialist': self.name,
                'analysis_type': 'investment_recommendation',
                'symbol': symbol,
                'analysis': f"Investment recommendation analysis error: {str(e)}",
                'timestamp': datetime.now().isoformat(),
                'error': True,
                'model_used': 'Error'
            }

class RoutingCoordinator:
    """Coordinates routing of analysis tasks to appropriate specialists"""
    
    def __init__(self, memory: AgentMemory):
        self.memory = memory
        self.specialists = {
            'technical': TechnicalAnalyst(memory),
            'fundamental': FundamentalAnalyst(memory),
            'news': NewsAnalyst(memory),
            'sec': SECFilingsAnalyst(memory),
            'recommendation': InvestmentRecommendationAnalyst(memory)
        }
        self.llm = llm
    
    def invoke_llm_with_logging(self, prompt: str, context: str = "") -> tuple:
        """Invoke LLM and log the model information along with response"""
        try:
            response = self.llm.invoke([HumanMessage(content=prompt)])
            
            # Extract model information
            # Extract model information
            model_name = getattr(response, 'response_metadata', {}).get('model_name', 'Unknown')
            if not model_name or model_name == 'Unknown':
                # Try to get model from LLM configuration
                model_name = getattr(self.llm, 'deployment_name', getattr(self.llm, 'model_name', 'Azure OpenAI Model'))
            
            # Get token count information
            token_count = 'N/A'
            if hasattr(response, 'usage_metadata') and response.usage_metadata:
                token_count = response.usage_metadata.get('total_tokens', 'N/A')
            elif hasattr(response, 'response_metadata') and response.response_metadata:
                usage = response.response_metadata.get('token_usage', {})
                if usage:
                    token_count = usage.get('total_tokens', 'N/A')
            
            # Print model information
            print(f"[ROUTING] Model: {model_name} | Tokens: {token_count} | Context: {context}")
            
            return response.content, model_name
            
        except Exception as e:
            print(f"LLM Error in {context}: {e}")
            return f"Error in LLM call: {str(e)}", "Error"
    
    def route_analysis(self, request: str, symbol: str) -> Dict[str, Any]:
        """Route analysis request to appropriate specialists"""
        routing_prompt = PromptConfiguration.get_routing_prompt(request, symbol)
        
        try:
            routing_text, model_name = self.invoke_llm_with_logging(
                routing_prompt, 
                f"Routing Decision for {symbol}"
            )
            
            try:
                routing_decision = json.loads(routing_text)
            except:
                # Default routing - use all specialists
                routing_decision = {
                    "specialists_needed": ["technical", "fundamental", "news", "sec", "recommendation"],
                    "priority_order": ["fundamental", "technical", "news", "sec", "recommendation"],
                    "reasoning": "Default comprehensive analysis including regulatory filings and investment recommendation"
                }
            
            routing_decision['routing_model_used'] = model_name
            
            # Execute analysis with selected specialists
            results = {}
            specialist_names = {
                'technical': 'TechnicalAnalyst',
                'fundamental': 'FundamentalAnalyst', 
                'news': 'NewsAnalyst',
                'sec': 'SECFilingsAnalyst',
                'recommendation': 'InvestmentRecommendationAnalyst'
            }
            
            for specialist_type in routing_decision.get('specialists_needed', []):
                if specialist_type in self.specialists:
                    specialist_name = specialist_names.get(specialist_type, specialist_type)
                    print(f"[ROUTING] Activating {specialist_name} for {symbol}")
                    
                    # For recommendation specialist, pass other analyses as context
                    analysis_data = {'specialist_analyses': results} if specialist_type == 'recommendation' else {}
                    
                    specialist_result = self.specialists[specialist_type].analyze(analysis_data, symbol)
                    results[specialist_type] = specialist_result
            
            return {
                'routing_decision': routing_decision,
                'specialist_analyses': results,
                'symbol': symbol,
                'request': request,
                'timestamp': datetime.now().isoformat()
            }
        
        except Exception as e:
            print(f"Error in routing: {e}")
            return {
                'error': f"Routing error: {str(e)}",
                'symbol': symbol,
                'timestamp': datetime.now().isoformat()
            }

# Initialize routing system
routing_coordinator = RoutingCoordinator(agent_memory)
print("[SYSTEM] Routing System (Specialist Agents) created")

[SYSTEM] Routing System (Specialist Agents) created

class EvaluatorOptimizer:
    """Implements Evaluator-Optimizer pattern: Generate → Evaluate → Refine"""
    
    def __init__(self, llm, memory: AgentMemory):
        self.llm = llm
        self.memory = memory
        self.max_iterations = 3
    
    def invoke_llm_with_logging(self, prompt: str, context: str = "") -> tuple:
        """Invoke LLM and log the model information along with response"""
        try:
            response = self.llm.invoke([HumanMessage(content=prompt)])
            
            # Extract model information
            model_name = getattr(response, 'response_metadata', {}).get('model_name', 'Unknown')
            if not model_name or model_name == 'Unknown':
                # Try to get model from LLM configuration
                model_name = getattr(self.llm, 'deployment_name', getattr(self.llm, 'model_name', 'Azure OpenAI Model'))
            
            # Get token count information
            token_count = 'N/A'
            if hasattr(response, 'usage_metadata') and response.usage_metadata:
                token_count = response.usage_metadata.get('total_tokens', 'N/A')
            elif hasattr(response, 'response_metadata') and response.response_metadata:
                usage = response.response_metadata.get('token_usage', {})
                if usage:
                    token_count = usage.get('total_tokens', 'N/A')
            
            # Print model information
            print(f"[OPTIMIZER] Model: {model_name} | Tokens: {token_count} | Context: {context}")

            return response.content, model_name
            
        except Exception as e:
            print(f"LLM Error in {context}: {e}")
            return f"Error in LLM call: {str(e)}", "Error"
    
    def generate_initial_analysis(self, symbol: str, specialist_analyses: Dict[str, Any]) -> str:
        """Generate initial comprehensive analysis"""
        specialist_analyses_str = json.dumps(specialist_analyses, indent=2)[:3000]
        
        # Create a comprehensive analysis prompt
        generate_prompt = f"""
        Create a comprehensive investment analysis for {symbol} based on these specialist analyses:
        
        {specialist_analyses_str}
        
        Provide a structured analysis covering:
        1. Executive Summary
        2. Technical Assessment
        3. Fundamental Analysis
        4. News and Sentiment
        5. Regulatory and SEC Filing Insights
        6. Investment Recommendation
        7. Risk Assessment
        8. Price Targets and Timeline
        
        Make it professional, actionable, and comprehensive for investment decision-making.
        """
        
        try:
            analysis, model_name = self.invoke_llm_with_logging(
                generate_prompt, 
                f"Initial Analysis Generation for {symbol}"
            )
            return analysis
        except Exception as e:
            return f"Error generating initial analysis: {str(e)}"
    
    def evaluate_analysis_quality(self, analysis: str, symbol: str) -> Dict[str, Any]:
        """Evaluate the quality of the analysis using Azure OpenAI"""
        evaluation_prompt = PromptConfiguration.get_evaluation_prompt(analysis, symbol)
        
        try:
            evaluation_text, model_name = self.invoke_llm_with_logging(
                evaluation_prompt, 
                f"Analysis Quality Evaluation for {symbol}"
            )
            
            try:
                evaluation = json.loads(evaluation_text)
                evaluation['evaluation_model_used'] = model_name
            except:
                # Fallback evaluation
                evaluation = {
                    "scores": {
                        "completeness": 7,
                        "data_integration": 6,
                        "risk_assessment": 6,
                        "actionability": 7,
                        "logic_reasoning": 7,
                        "market_context": 6,
                        "clarity": 7
                    },
                    "overall_score": 6.5,
                    "grade": "B",
                    "strengths": ["Basic analysis provided"],
                    "weaknesses": ["Could be more detailed"],
                    "specific_improvements": ["Add more quantitative analysis"],
                    "missing_elements": ["Market comparisons"],
                    "evaluation_model_used": model_name
                }
            
            return evaluation
        
        except Exception as e:
            print(f"Error in evaluation: {e}")
            return {
                "overall_score": 5,
                "grade": "C",
                "strengths": ["Attempt made"],
                "weaknesses": ["Evaluation error"],
                "specific_improvements": ["Retry analysis"],
                "missing_elements": ["Complete analysis"],
                "evaluation_model_used": "Error"
            }
    
    def refine_analysis(self, original_analysis: str, evaluation: Dict[str, Any], symbol: str) -> str:
        """Refine analysis based on evaluation feedback"""
        evaluation_str = json.dumps(evaluation, indent=2)
        refinement_prompt = PromptConfiguration.get_refinement_prompt(original_analysis, evaluation_str, symbol)
        
        try:
            refined_analysis, model_name = self.invoke_llm_with_logging(
                refinement_prompt, 
                f"Analysis Refinement for {symbol}"
            )
            return refined_analysis
        except Exception as e:
            return f"Error in refinement: {str(e)}. Original analysis maintained."
    
    def optimize_analysis(self, symbol: str, specialist_analyses: Dict[str, Any]) -> Dict[str, Any]:
        """Execute the complete evaluator-optimizer loop"""
        print(f"Starting analysis optimization for {symbol}...")
        
        iterations = []
        current_analysis = self.generate_initial_analysis(symbol, specialist_analyses)
        
        for iteration in range(self.max_iterations):
            print(f"Optimization iteration {iteration + 1}/{self.max_iterations}")
            
            # Evaluate current analysis
            evaluation = self.evaluate_analysis_quality(current_analysis, symbol)
            
            iteration_data = {
                'iteration': iteration + 1,
                'analysis': current_analysis,
                'evaluation': evaluation,
                'timestamp': datetime.now().isoformat()
            }
            
            # Check if quality is acceptable (grade A or B, or score > 8)
            overall_score = evaluation.get('overall_score', 0)
            grade = evaluation.get('grade', 'F')
            
            if grade in ['A', 'B'] or overall_score >= 8.0:
                print(f"Analysis quality acceptable (Grade: {grade}, Score: {overall_score})")
                iteration_data['optimization_complete'] = True
                iterations.append(iteration_data)
                break
            
            # Refine analysis if quality is not acceptable
            if iteration < self.max_iterations - 1:  # Don't refine on last iteration
                print(f"Refining analysis (Grade: {grade}, Score: {overall_score})")
                current_analysis = self.refine_analysis(current_analysis, evaluation, symbol)
                iteration_data['refinement_applied'] = True
            else:
                print(f"Maximum iterations reached. Final grade: {grade}, Score: {overall_score}")
                iteration_data['max_iterations_reached'] = True
            
            iterations.append(iteration_data)
        
        # Store learning in memory
        final_evaluation = iterations[-1]['evaluation']
        learning_content = f"""
        Analysis Optimization for {symbol}:
        Iterations: {len(iterations)}
        Final Grade: {final_evaluation.get('grade', 'N/A')}
        Final Score: {final_evaluation.get('overall_score', 'N/A')}
        Strengths: {', '.join(final_evaluation.get('strengths', []))}
        Improvements: {', '.join(final_evaluation.get('specific_improvements', []))}
        """
        
        optimization_metadata = {
            'type': 'optimization_learning',
            'symbol': symbol,
            'iterations': len(iterations),
            'final_score': final_evaluation.get('overall_score', 0),
            'timestamp': datetime.now().isoformat()
        }
        
        self.memory.add_memory(learning_content, optimization_metadata)
        
        return {
            'symbol': symbol,
            'optimization_iterations': iterations,
            'final_analysis': current_analysis,
            'final_evaluation': final_evaluation,
            'improvement_achieved': len(iterations) > 1,
            'timestamp': datetime.now().isoformat()
        }

# Initialize evaluator-optimizer
evaluator_optimizer = EvaluatorOptimizer(llm, agent_memory)
print("[SYSTEM] Evaluator-Optimizer system created")

[SYSTEM] Evaluator-Optimizer system created

class SummarizerAgent(InvestmentResearchAgent):
    """Specialized agent that creates concise, executive-level summaries of each specialist analysis"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("SummarizerAgent", "Executive Analysis Summarizer", memory)
        self.summary_templates = {            
            'recommendation': {
                'title': 'Investment Recommendation Summary',
                'focus_areas': ['buy/sell/hold rating', 'price target', 'confidence level', 'risk assessment', 'time horizon'],
                'output_format': 'Clear recommendation, target price, risk level, rationale'
            },
            'technical': {
                'title': 'Technical Analysis Summary',
                'focus_areas': ['price trends', 'technical indicators', 'support/resistance levels', 'momentum', 'volume analysis'],
                'output_format': 'Technical outlook, key levels, trading recommendation'
            },
            'fundamental': {
                'title': 'Fundamental Analysis Summary', 
                'focus_areas': ['financial health', 'valuation metrics', 'growth prospects', 'competitive position', 'business model'],
                'output_format': 'Financial strength, valuation assessment, growth outlook'
            },
            'news': {
                'title': 'News & Sentiment Summary',
                'focus_areas': ['market sentiment', 'recent developments', 'analyst opinions', 'industry trends', 'public perception'],
                'output_format': 'Sentiment direction, key news impacts, market perception'
            },
            'sec': {
                'title': 'SEC Filings & Regulatory Summary',
                'focus_areas': ['regulatory compliance', 'financial disclosures', 'risk factors', 'governance issues', 'material events'],
                'output_format': 'Regulatory status, material changes, compliance assessment'
            }
        }
    
    def summarize_specialist_analysis(self, specialist_type: str, analysis_data: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Create a concise summary of a specialist's analysis"""
        
        if specialist_type not in self.summary_templates:
            return self._create_error_summary(specialist_type, "Unknown specialist type", symbol)
        
        template = self.summary_templates[specialist_type]
        analysis_content = analysis_data.get('analysis', '')
        
        if not analysis_content or analysis_data.get('error'):
            return self._create_error_summary(specialist_type, analysis_data.get('analysis', 'No analysis available'), symbol)
        
        # Use PromptConfiguration for standardized prompts
        summary_prompt = PromptConfiguration.get_specialist_summary_prompt(
            specialist_type,
            analysis_content,
            symbol,
            template['focus_areas'],
            template['output_format']
        )
        
        try:
            summary, model_name = self.invoke_llm_with_logging(
                summary_prompt, 
                f"{template['title']} Summary for {symbol}"
            )
            
            return {
                'specialist_type': specialist_type,
                'title': template['title'],
                'symbol': symbol,
                'summary': summary,
                'original_length': len(analysis_content),
                'summary_length': len(summary),
                'compression_ratio': round(len(summary) / len(analysis_content), 2),
                'timestamp': datetime.now().isoformat(),
                'model_used': model_name,
                'focus_areas': template['focus_areas']
            }
            
        except Exception as e:
            return self._create_error_summary(specialist_type, f"Summarization error: {str(e)}", symbol)
    
    def create_comprehensive_summary(self, all_specialist_analyses: Dict[str, Any], symbol: str) -> Dict[str, Any]:
        """Create an overall comprehensive summary combining all specialist summaries"""
        
        # First, create individual summaries
        specialist_summaries = {}
        total_original_length = 0
        
        for specialist_type, analysis_data in all_specialist_analyses.items():
            if isinstance(analysis_data, dict):
                summary = self.summarize_specialist_analysis(specialist_type, analysis_data, symbol)
                specialist_summaries[specialist_type] = summary
                total_original_length += summary.get('original_length', 0)
        
        # Create executive summary combining all analyses
        combined_summaries_text = ""
        for spec_type, summary_data in specialist_summaries.items():
            combined_summaries_text += f"\n{summary_data.get('title', spec_type)}:\n{summary_data.get('summary', 'No summary available')}\n"
        
        # Use PromptConfiguration for standardized executive summary prompt
        executive_summary_prompt = PromptConfiguration.get_executive_summary_prompt(combined_summaries_text, symbol)
        
        try:
            executive_summary, model_name = self.invoke_llm_with_logging(
                executive_summary_prompt, 
                f"Executive Summary for {symbol}"
            )
            
            return {
                'symbol': symbol,
                'executive_summary': executive_summary,
                'specialist_summaries': specialist_summaries,
                'analysis_coverage': list(specialist_summaries.keys()),
                'total_specialists': len(specialist_summaries),
                'total_original_length': total_original_length,
                'total_summary_length': sum(s.get('summary_length', 0) for s in specialist_summaries.values()) + len(executive_summary),
                'overall_compression_ratio': round((sum(s.get('summary_length', 0) for s in specialist_summaries.values()) + len(executive_summary)) / max(total_original_length, 1), 2),
                'timestamp': datetime.now().isoformat(),
                'model_used': model_name
            }
            
        except Exception as e:
            return {
                'symbol': symbol,
                'executive_summary': f"Error creating executive summary: {str(e)}",
                'specialist_summaries': specialist_summaries,
                'error': True,
                'timestamp': datetime.now().isoformat()
            }
    
    def _create_error_summary(self, specialist_type: str, error_msg: str, symbol: str) -> Dict[str, Any]:
        """Create an error summary when analysis fails"""
        return {
            'specialist_type': specialist_type,
            'title': self.summary_templates.get(specialist_type, {}).get('title', f'{specialist_type} Analysis Summary'),
            'symbol': symbol,
            'summary': f"**Analysis Unavailable:** {error_msg}",
            'original_length': 0,
            'summary_length': len(error_msg),
            'compression_ratio': 0,
            'timestamp': datetime.now().isoformat(),
            'error': True,
            'model_used': 'Error'
        }

    def generate_summary_report(self, routing_results: Dict[str, Any], symbol: str) -> str:
        """Generate a formatted summary report for display"""
        
        specialist_analyses = routing_results.get('specialist_analyses', {})
        comprehensive_summary = self.create_comprehensive_summary(specialist_analyses, symbol)
        
        # Build formatted report without emojis
        report = f"""# Investment Analysis Summary - {symbol}
## Executive Summary
{comprehensive_summary.get('executive_summary', 'Executive summary unavailable')}

## Detailed Analysis Summaries

"""
        
        # Add individual specialist summaries
        specialist_summaries = comprehensive_summary.get('specialist_summaries', {})
        
        # Order of display
        display_order = ['recommendation', 'fundamental', 'technical', 'news', 'sec']
        
        for specialist_type in display_order:
            if specialist_type in specialist_summaries:
                summary_data = specialist_summaries[specialist_type]
                
                report += f"""### {summary_data.get('title', specialist_type)}
                            {summary_data.get('summary', 'Summary unavailable')}

**Analysis Stats:** {summary_data.get('original_length', 0):,} chars → {summary_data.get('summary_length', 0)} chars (compression: {summary_data.get('compression_ratio', 0):.1%})

"""
        
        # Add analysis metadata
        report += f"""## Analysis Metadata
        
**Coverage:** {comprehensive_summary.get('total_specialists', 0)} specialist analyses  
**Total Content:** {comprehensive_summary.get('total_original_length', 0):,} characters  
**Summary Length:** {comprehensive_summary.get('total_summary_length', 0):,} characters  
**Compression Ratio:** {comprehensive_summary.get('overall_compression_ratio', 0):.1%}  
**Generated:** {comprehensive_summary.get('timestamp', 'Unknown')}  
**Model Used:** {comprehensive_summary.get('model_used', 'Unknown')}
"""
        
        return report

# Initialize the Summarizer Agent
summarizer_agent = SummarizerAgent(agent_memory)
print("[SYSTEM] Summarizer Agent initialized")

[SYSTEM] Summarizer Agent initialized

class MainInvestmentResearchAgent(InvestmentResearchAgent):
    """Main coordinator agent that orchestrates all workflows and patterns"""
    
    def __init__(self, memory: AgentMemory):
        super().__init__("MainCoordinator", "Investment Research Coordinator", memory)
        self.routing_coordinator = routing_coordinator
        self.evaluator_optimizer = evaluator_optimizer
        self.news_chain = news_chain
        self.summarizer_agent = summarizer_agent  # Add summarizer agent
        
    def conduct_comprehensive_research(self, symbol: str, request: str = None) -> Dict[str, Any]:
        """
        Conduct comprehensive investment research using all three workflow patterns:
        1. Prompt Chaining (News Processing)
        2. Routing (Specialist Analysis) 
        3. Evaluator-Optimizer (Analysis Refinement)
        """
        print(f"[MAIN AGENT] Initiating comprehensive research | Symbol: {symbol}")
        
        # Step 1: Planning
        if not request:
            request = f"Conduct comprehensive investment analysis for {symbol} including technical, fundamental, and sentiment analysis"
        
        research_plan = self.plan_research(request)
        print(f"[PLANNING] Research plan created | Steps: {len(research_plan)}")
        
        # Step 2: Retrieve past experience
        past_experiences = self.retrieve_relevant_experience(request)
        if past_experiences:
            print(f"[MEMORY] Retrieved past experiences | Count: {len(past_experiences)}")
        
        # Step 3: Execute Routing Workflow (Specialist Analysis)
        print(f"[ROUTING] Executing specialist analysis workflow")
        routing_results = self.routing_coordinator.route_analysis(request, symbol)
        
        # Step 4: Execute Prompt Chaining (News Processing) - included in news specialist
        print(f"[NEWS CHAIN] Processing completed within specialist analysis")

        # Step 5: Execute Evaluator-Optimizer Workflow
        print(f"[OPTIMIZER] Executing analysis optimization workflow")
        specialist_analyses = routing_results.get('specialist_analyses', {})
        optimization_results = self.evaluator_optimizer.optimize_analysis(symbol, specialist_analyses)
        
        # Step 6: Self-reflect on overall process
        print(f"[REFLECTION] Conducting analysis quality assessment")
        final_analysis = optimization_results.get('final_analysis', '')
        reflection = self.self_reflect(final_analysis)
        
        # Step 7: Learn from this experience
        print(f"[LEARNING] Storing research experience for future optimization")
        self.learn_from_experience(request, final_analysis, reflection)
        
        # Compile comprehensive results
        comprehensive_results = {
            'symbol': symbol,
            'request': request,
            'research_plan': research_plan,
            'past_experiences': past_experiences,
            'routing_results': routing_results,
            'optimization_results': optimization_results,
            'self_reflection': reflection,
            'execution_log': self.execution_log,
            'timestamp': datetime.now().isoformat(),
            'agent_name': self.name
        }

        print(f"[MAIN AGENT] Research completed | Quality Score: {reflection.get('overall_score', 'N/A')}/10")
        
        return comprehensive_results
    
    def generate_investment_report(self, research_results: Dict[str, Any]) -> str:
        """Generate a formatted investment report from research results"""
        symbol = research_results.get('symbol', 'N/A')
        final_analysis = research_results.get('optimization_results', {}).get('final_analysis', '')
        reflection = research_results.get('self_reflection', {})
        
        report_template = f"""
        # Investment Research Report: {symbol}
        **Generated on:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
        **Research Quality Score:** {reflection.get('overall_score', 'N/A')}/10

## Executive Summary
{final_analysis[:500]}...

## Key Research Insights
- **Research Plan Execution:** {len(research_results.get('research_plan', []))} planned steps completed
- **Specialist Analyses:** {len(research_results.get('routing_results', {}).get('specialist_analyses', {}))} specialist reports generated
- **Analysis Iterations:** {len(research_results.get('optimization_results', {}).get('optimization_iterations', []))} optimization cycles
- **Quality Improvements:** {'Yes' if research_results.get('optimization_results', {}).get('improvement_achieved', False) else 'No'}

## Analysis Quality Assessment
- **Strengths:** {', '.join(reflection.get('strengths', ['Analysis completed']))}
- **Recommendations:** {', '.join(reflection.get('recommendations', ['Continue monitoring']))}

## Full Analysis
{final_analysis}

---
*This report was generated by an AI Investment Research Agent.*
"""
        
        return report_template
    
    def generate_summarized_report(self, routing_results: Dict[str, Any], symbol: str) -> str:
        """Generate a concise summarized report using the SummarizerAgent - THIS IS THE PRIMARY OUTPUT METHOD"""
        try:
            # Use the summarizer agent to create executive summaries
            print(f"[SUMMARIZER] Generating executive summary report | Symbol: {symbol}")
            summarized_report = self.summarizer_agent.generate_summary_report(routing_results, symbol)
            print(f"[SUMMARIZER] Report generation completed successfully")
            return summarized_report
        except Exception as e:
            # Fallback to detailed analysis if summarizer fails
            print(f"[SUMMARIZER] Warning: Summarizer failed ({e}), using fallback analysis")
            return self.generate_routing_report(routing_results, symbol, "Comprehensive Analysis")
    
    def generate_routing_report(self, routing_results: Dict[str, Any], symbol: str, analysis_type: str) -> str:
        """Generate a report for routing-based analysis (fallback method)"""
        
        report = f"""# {analysis_type} Report for {symbol}

                ## Analysis Overview
                This analysis was conducted using our specialized agent routing system.
                """
                                
        # Add specialist analyses
        specialist_analyses = routing_results.get('specialist_analyses', {})
        
        for specialist, analysis in specialist_analyses.items():
            specialist_name = specialist.replace('_', ' ').title()
            report += f"""
                    ## {specialist_name} Analysis

                    {str(analysis)[:2000]}{'...' if len(str(analysis)) > 2000 else ''}

                    ---
                    """
        
        # Add routing decision info
        routing_decision = routing_results.get('routing_decision', {})
        if routing_decision:
            report += f"""
                        ## Analysis Methodology

                        **Routing Decision:** {routing_decision.get('reasoning', 'N/A')}

                        **Specialists Activated:** {list(specialist_analyses.keys())}

                        **Analysis Confidence:** Based on specialist expertise and data availability
                        """
        
        return report

# Initialize main research agent
main_research_agent = MainInvestmentResearchAgent(agent_memory)
print("[SYSTEM] Main Investment Research Agent Coordinator initialized")

[SYSTEM] Main Investment Research Agent Coordinator initialized

# Test Configuration
TEST_SYMBOL = "AAPL"  # Apple Inc. - change this to test other symbols

# Test Configuration - Enable/Disable Individual Tests
TEST_CONFIG = {
    "quick": True,                     # Test 1: Quick Analysis Assessment
    "comprehensive": True,             # Test 2: Comprehensive Analysis (Full System Test)
    "technical": True,                 # Test 3: Technical Analysis
    "fundamental": True,               # Test 4: Fundamental Analysis
    "news_sentiment": True,            # Test 5: News & Sentiment Analysis
    "investment_recommendation": True  # Test 6: Investment Recommendation Analysis
}

print("[TEST] Configuration:")
print(f"Symbol: {TEST_SYMBOL} (Apple Inc.)")
print("\nTest Configuration:")
for test_name, enabled in TEST_CONFIG.items():
    status = "ENABLED" if enabled else "DISABLED"
    print(f"  {test_name.replace('_', ' ').title()}: {status}")
print("Ready for individual analysis testing")
print("=" * 60)

[TEST] Configuration:
Symbol: AAPL (Apple Inc.)

Test Configuration:
  Quick: ENABLED
  Comprehensive: ENABLED
  Technical: ENABLED
  Fundamental: ENABLED
  News Sentiment: ENABLED
  Investment Recommendation: ENABLED
Ready for individual analysis testing
============================================================

# Test 1: Quick Analysis
if TEST_CONFIG.get("quick", True):
    print("[TEST] Quick Analysis Assessment")
    print(f"Symbol: {TEST_SYMBOL}")
    print("Analysis Type: Fast summary with key metrics and recommendation")

    start_time = time.time()

    try:
        with suppress_llm_logs():
            quick_request = f"Provide quick investment summary for {TEST_SYMBOL} with key metrics and recommendation"
            
            quick_results = routing_coordinator.route_analysis(quick_request, TEST_SYMBOL)
        
        # Calculate metrics
        execution_time = time.time() - start_time
        analysis_length = len(str(quick_results))
        specialists_activated = list(quick_results.get('specialist_analyses', {}).keys())
        
        print(f"[TEST] Quick Analysis completed | Time: {execution_time:.2f}s | Length: {analysis_length:,} chars | Specialists: {specialists_activated}")
        
        # Print final agent response
        print(f"\nFINAL AGENT RESPONSE:")
        print("=" * 60)
        # Map specialist types to full agent names
        specialist_names = {
            'technical': 'TechnicalAnalyst',
            'fundamental': 'FundamentalAnalyst',
            'news': 'NewsAnalyst',
            'sec': 'SECFilingsAnalyst',
            'recommendation': 'InvestmentRecommendationAnalyst'
        }
        
        for specialist, analysis in quick_results.get('specialist_analyses', {}).items():
            specialist_name = specialist_names.get(specialist, specialist.title())
            print(f"\n{specialist_name.upper()} ANALYSIS:")
            print("-" * 40)
            analysis_content = analysis.get('analysis', 'No analysis content available')
            # Truncate very long responses for readability
            if len(analysis_content) > 1000:
                print(f"{analysis_content[:1000]}...")
                print(f"\n[Response truncated - showing first 1000 characters of {len(analysis_content)} total]")
            else:
                print(analysis_content)
        print("=" * 60)
        
        # Store results for summary
        quick_test_result = {
            "success": True,
            "execution_time": execution_time,
            "analysis_length": analysis_length,
            "specialists_activated": specialists_activated,
            "agent_response": quick_results
        }

    except Exception as e:
        print(f"[TEST] Quick Analysis failed: {str(e)}")
        quick_test_result = {"success": False, "error": str(e)}
else:
    print("[TEST] Quick Analysis - SKIPPED (disabled in configuration)")
    quick_test_result = {"success": False, "error": "Test disabled in configuration"}

[TEST] Quick Analysis Assessment
Symbol: AAPL
Analysis Type: Fast summary with key metrics and recommendation
[ROUTING] Model: gpt-5-mini-2025-08-07 | Tokens: 424 | Context: Routing Decision for AAPL
[ROUTING] Activating FundamentalAnalyst for AAPL
[DATA] Stock data retrieved for AAPL from Yahoo Finance
[CACHE] Stored stock_data data | Symbol: AAPL
[DATA] Alpha Vantage data retrieved for AAPL function OVERVIEW
[CACHE] Stored alpha_vantage data | Symbol: AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 2355 | Context: Fundamental Analysis for AAPL
[CACHE] Stored fundamental analysis | Symbol: AAPL
[ROUTING] Activating NewsAnalyst for AAPL
[NEWS CHAIN] Initiating processing pipeline | Symbol: AAPL
[NEWS CHAIN] Step 1: News ingestion
[DATA] News retrieved for AAPL from NewsAPI
[CACHE] Stored stock_news data | Symbol: AAPL
[NEWS CHAIN] Step 2: News preprocessing
[NEWS CHAIN] Step 3: News classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 319 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 347 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 328 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 287 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 276 | Context: News Classification
[NEWS CHAIN] Step 4: Insight extraction
[NEWS CHAIN] Model: o4-mini-2025-04-16 | Tokens: 901 | Context: Insights Extraction
[NEWS CHAIN] Step 5: Summary generation
[NEWS CHAIN] Model: gpt-5-mini-2025-08-07 | Tokens: 1049 | Context: News Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1677 | Context: Sentiment Analysis for AAPL
[ROUTING] Activating SECFilingsAnalyst for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 1859 | Context: SEC Filings Analysis for AAPL
[ROUTING] Activating TechnicalAnalyst for AAPL
[DATA] Stock data retrieved for AAPL from Yahoo Finance
[CACHE] Stored stock_data data | Symbol: AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 3114 | Context: Technical Analysis for AAPL
[CACHE] Stored technical analysis | Symbol: AAPL
[ROUTING] Activating InvestmentRecommendationAnalyst for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 1647 | Context: Investment Recommendation for AAPL
[CACHE] Stored recommendation analysis | Symbol: AAPL
[TEST] Quick Analysis completed | Time: 101.17s | Length: 44,266 chars | Specialists: ['fundamental', 'news', 'sec', 'technical', 'recommendation']

FINAL AGENT RESPONSE:
============================================================

FUNDAMENTALANALYST ANALYSIS:
----------------------------------------
**Fundamental Analysis: Apple Inc. (AAPL)**  
*As of Current Price: $252.29*  

---

### 1. Financial Health Assessment  
Apple Inc. exhibits a robust financial position, underscored by its massive market capitalization of approximately $3.74 trillion, evidencing its status as one of the largest and financially sound technology companies globally. The company’s earnings per share (EPS) stand at $6.58, reflecting solid profitability. While detailed balance sheet data (such as debt levels and cash reserves) is not available here, Apple historically maintains strong liquidity, significant cash holdings, and manageable debt, which supports ongoing R&D, product expansion, and shareholder returns. The volume of ~48.9 million shares traded daily (close to average volume of ~53.96 million) confirms strong market liquidity. Overall, Apple’s financial health remains excellent, positioning it well to withstand economic uncertainties.

---

### 2. Valuation Metrics Analysis  
- **Price/Earnings (P...

[Response truncated - showing first 1000 characters of 6542 total]

NEWSANALYST ANALYSIS:
----------------------------------------
Overall sentiment assessment
1. Net leaning: Mildly positive. Of the classified sample, headline and content signals (improved margins/per‑share earnings, cautious product skepticism) point to a constructive view on fundamentals with tempered near‑term growth enthusiasm.
2. Sentiment strength: Moderately positive—high conviction on margin improvement and capital return benefits; neutral-to-slightly-negative on incremental product catalysts (e.g., foldable phone unlikely to materially change revenue trajectory).
3. Time horizon: Positive bias over medium term (6–24 months) driven by buybacks and services growth; short term (days–weeks) mixed due to product cycle and macro influences.

Market perception trends
1. Rotation toward quality income and cash returns: Analysts and media emphasize buybacks and EPS accretion, framing Apple as a shareholder‑friendly, lower‑beta large cap rather than a high‑growth story.
2. Product skepticism coexisting with fundamentals: Coverage differentiates be...

[Response truncated - showing first 1000 characters of 5946 total]

SECFILINGSANALYST ANALYSIS:
----------------------------------------
Regulatory analysis framework for Apple Inc. (AAPL) based on SEC filings (without direct access to current filings)

Note: The following analysis is structured to guide review of Apple’s SEC 10-K, 10-Qs, 8-Ks, and related proxy and governance materials. Because the SEC data tool is unavailable in this session, please supply the specific filing dates or documents if you want item-by-item extraction. The sections below indicate key disclosures to examine and typical impacts for investment decisions.

1) Key regulatory disclosures to scrutinize
- Risk disclosures (Item 1A in 10-K; incorporated in quarterly 10-Qs):
  - Market and product concentration risk (iPhone mix, Services growth, wearables).
  - Supply chain exposure and concentration risk (single-source suppliers, geopolitical risk in China, Taiwan-dependent components).
  - Regulatory and antitrust risk (competition investigations, app store governance, developer relations).
  - Foreign exchange and international operations risk.
 ...

[Response truncated - showing first 1000 characters of 8271 total]

TECHNICALANALYST ANALYSIS:
----------------------------------------
Summary
- AAPL is trading at 252.29, up ~1.96% on the session and trading slightly below its 52‑week high (259.24). Recent price action shows a short-term uptrend with normal pullbacks and buyers stepping in near the mid‑245 area. Volume today (48.9M) is a bit below the reported average (≈53.8M), suggesting the move is not yet accompanied by strong conviction from a volume perspective.
- Technical bias: short‑term bullish-to-neutral. Price is trading around its short-term moving average zone and below the immediate resistance at the recent swing highs. Manageable supports lie in the 245–238 area; failure below those levels flips the short-term bias toward neutral/bearish.

1) Price trends and patterns
- Trend (short term): Uptrend/rotation — over the most recent 2–6 weeks the stock has made higher lows (roughly low‑245 after a small dip) and recent higher highs around 256–258 before a small consolidation. The last 10 sessions’ simple average is ~251.5 and the current price sits slightl...

[Response truncated - showing first 1000 characters of 5938 total]

INVESTMENTRECOMMENDATIONANALYST ANALYSIS:
----------------------------------------
Investment Recommendation: Apple Inc. (AAPL)

Current Price: 252.29 USD

1) Investment Thesis
- Durable competitive position: Apple remains a leader in hardware quality, ecosystem lock-in (iOS/macOS services), and brand strength. Services and wearables continue to offer higher-margin growth that complements hardware cycles.
- Revenue resilience with product cycle upside: While iPhone remains the primary driver, Services, Wearables, and Mac/Other categories provide diversification and margin expansion potential, supporting cash flow stability in a higher-rate environment.
- Balance sheet and capital returns: Generous buyback program and dividend support shareholder value while maintaining capacity to invest in R&D, platform ecosystems, and strategic acquisitions if opportunities arise.
- Modest near-term macro headwinds but supportive long-term growth: Macro pressures exist (tightening consumer spend, supply chain dynamics), yet Apple’s pricing power and ecosystem moat help mitigate mar...

[Response truncated - showing first 1000 characters of 5235 total]
============================================================

# Test 2: Comprehensive Analysis
if TEST_CONFIG.get("comprehensive", True):
    print("[TEST] Comprehensive Analysis")
    print(f"Symbol: {TEST_SYMBOL}")
    print("Analysis Type: Full system test with all specialists")

    start_time = time.time()

    try:
        with suppress_llm_logs():
            # Run comprehensive research with all specialists
            comprehensive_request = f"Conduct comprehensive investment analysis for {TEST_SYMBOL} including technical, fundamental, and sentiment analysis with detailed recommendations"
            
            comprehensive_results = main_research_agent.conduct_comprehensive_research(
                symbol=TEST_SYMBOL, 
                request=comprehensive_request
            )
            
            # Generate investment report
            investment_report = main_research_agent.generate_investment_report(comprehensive_results)
        
        # Calculate metrics
        execution_time = time.time() - start_time
        quality_score = comprehensive_results.get('self_reflection', {}).get('overall_score', 'N/A')
        specialists_used = len(comprehensive_results.get('routing_results', {}).get('specialist_analyses', {}))
        optimization_cycles = len(comprehensive_results.get('optimization_results', {}).get('optimization_iterations', []))
        report_length = len(investment_report)
        
        print(f"[TEST] Comprehensive Analysis completed | Time: {execution_time:.2f}s | Quality: {quality_score}/10 | Specialists: {specialists_used} | Cycles: {optimization_cycles}")
        
        # Print final agent response (investment report)
        print(f"\nFINAL INVESTMENT REPORT:")
        print("=" * 60)
        # Truncate very long reports for readability
        if len(investment_report) > 2000:
            print(f"{investment_report[:2000]}...")
            print(f"\n[Report truncated - showing first 2000 characters of {len(investment_report)} total]")
        else:
            print(investment_report)
        print("=" * 60)
        
        # Store results for summary
        comprehensive_test_result = {
            "success": True,
            "execution_time": execution_time,
            "quality_score": quality_score,
            "specialists_used": specialists_used,
            "optimization_cycles": optimization_cycles,
            "report_length": report_length,
            "full_results": comprehensive_results,
            "investment_report": investment_report
        }

    except Exception as e:
        print(f"[TEST] Comprehensive Analysis failed: {str(e)}")
        comprehensive_test_result = {"success": False, "error": str(e)}
else:
    print("[TEST] Comprehensive Analysis - SKIPPED (disabled in configuration)")
    quick_test_result = {"success": False, "error": "Test disabled in configuration"}

[TEST] Comprehensive Analysis
Symbol: AAPL
Analysis Type: Full system test with all specialists
[MAIN AGENT] Initiating comprehensive research | Symbol: AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 2446 | Context: MainCoordinator - Research Planning
[PLANNING] Research plan created | Steps: 104
[ROUTING] Executing specialist analysis workflow
[ROUTING] Model: gpt-5-mini-2025-08-07 | Tokens: 408 | Context: Routing Decision for AAPL
[ROUTING] Activating FundamentalAnalyst for AAPL
[CACHE] Using cached fundamental analysis | Symbol: AAPL
[ROUTING] Activating SECFilingsAnalyst for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 2282 | Context: SEC Filings Analysis for AAPL
[ROUTING] Activating NewsAnalyst for AAPL
[NEWS CHAIN] Initiating processing pipeline | Symbol: AAPL
[NEWS CHAIN] Step 1: News ingestion
[CACHE] Using cached stock_news data | Symbol: AAPL
[NEWS CHAIN] Step 2: News preprocessing
[NEWS CHAIN] Step 3: News classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 447 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 412 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 327 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 346 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 333 | Context: News Classification
[NEWS CHAIN] Step 4: Insight extraction
[NEWS CHAIN] Model: o4-mini-2025-04-16 | Tokens: 905 | Context: Insights Extraction
[NEWS CHAIN] Step 5: Summary generation
[NEWS CHAIN] Model: gpt-4.1-mini-2025-04-14 | Tokens: 828 | Context: News Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1596 | Context: Sentiment Analysis for AAPL
[ROUTING] Activating TechnicalAnalyst for AAPL
[CACHE] Using cached technical analysis | Symbol: AAPL
[ROUTING] Activating InvestmentRecommendationAnalyst for AAPL
[CACHE] Using cached recommendation analysis | Symbol: AAPL
[NEWS CHAIN] Processing completed within specialist analysis
[OPTIMIZER] Executing analysis optimization workflow
Starting analysis optimization for AAPL...
[OPTIMIZER] Model: gpt-5-nano-2025-08-07 | Tokens: 2835 | Context: Initial Analysis Generation for AAPL
Optimization iteration 1/3
[OPTIMIZER] Model: gpt-5-nano-2025-08-07 | Tokens: 2944 | Context: Analysis Quality Evaluation for AAPL
Analysis quality acceptable (Grade: B, Score: 7.8)
[REFLECTION] Conducting analysis quality assessment
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 2529 | Context: MainCoordinator - Self Reflection
[LEARNING] Storing research experience for future optimization
MainCoordinator learned from experience (Score: 7)
[MAIN AGENT] Research completed | Quality Score: 7/10
[TEST] Comprehensive Analysis completed | Time: 75.70s | Quality: 7/10 | Specialists: 5 | Cycles: 1

FINAL INVESTMENT REPORT:
============================================================

        # Investment Research Report: AAPL
        **Generated on:** 2025-10-19 01:10:09
        **Research Quality Score:** 7/10

## Executive Summary
Executive Summary
- Apple Inc. (AAPL) sits at the center of technology leadership with a diversified, high-margin mix of hardware, software, and services. The stock trades at a premium multiple reflective of strong earnings growth and ecosystem monetization.
- Current price: 252.29. Market cap ~$3.74 trillion. Daily trading volume ~48.9 million (well above liquidity needs).
- Key valuation signals: P/E ~38.34, PEG ~2.47, dividend yield ~0.41%. 52-week range: 168.80 – 259.24, with current price n...

## Key Research Insights
- **Research Plan Execution:** 104 planned steps completed
- **Specialist Analyses:** 5 specialist reports generated
- **Analysis Iterations:** 1 optimization cycles
- **Quality Improvements:** No

## Analysis Quality Assessment
- **Strengths:** Clear structure covering executive summary, technical, fundamental, regulatory, and action sections—good breadth for an investor note., Balanced view: acknowledges long-term strengths while flagging valuation and regulatory risks, with concrete entry/exit suggestions (staged entry, target ranges, stop-loss guidance)., Reasonable, scenario-based price targets and catalyst list tied to earnings, services, product cycles, and regulations—useful for monitoring.
- **Recommendations:** Add key current financials and trends: trailing and forward revenues, EPS growth rates, gross/operating/net margin history, free cash flow, cash & short-term investments, and net debt. Include the dates/source for price and multiples to ensure currency., Include a concise valuation appendix: show the model(s) used for base/bull/bear cases (e.g., DCF assumptions or a multiples bridge), and sensitivity tables that vary revenue growth, margin, and discount/multiple to show how targets move., Improve risk quantification and competitive analysis: estimate potential earnings or margin ...

[Report truncated - showing first 2000 characters of 11643 total]
============================================================

# Test 3: Technical Analysis
if TEST_CONFIG.get("technical", True):
    print("[TEST] Technical Analysis")
    print(f"Symbol: {TEST_SYMBOL}")
    print("Analysis Type: Technical patterns, indicators, and trends")

    start_time = time.time()

    try:
        with suppress_llm_logs():
            technical_request = f"Perform detailed technical analysis on {TEST_SYMBOL} stock including chart patterns, indicators, and price trends"
            
            technical_results = routing_coordinator.route_analysis(technical_request, TEST_SYMBOL)
        
        # Calculate metrics
        execution_time = time.time() - start_time
        analysis_length = len(str(technical_results))
        specialists_activated = list(technical_results.get('specialist_analyses', {}).keys())
        routing_reasoning = technical_results.get('routing_decision', {}).get('reasoning', 'N/A')
        
        print(f"Technical Analysis COMPLETED")
        print(f"   Execution Time: {execution_time:.2f} seconds")
        print(f"   Analysis Length: {analysis_length:,} characters")
        print(f"   Specialists Activated: {specialists_activated}")
        
        # Print final agent response
        print(f"\nFINAL AGENT RESPONSE:")
        print("=" * 60)
        print(f"Routing Reasoning: {routing_reasoning}")
        print()
        # Map specialist types to full agent names
        specialist_names = {
            'technical': 'TechnicalAnalyst',
            'fundamental': 'FundamentalAnalyst',
            'news': 'NewsAnalyst',
            'sec': 'SECFilingsAnalyst',
            'recommendation': 'InvestmentRecommendationAnalyst'
        }
        
        for specialist, analysis in technical_results.get('specialist_analyses', {}).items():
            specialist_name = specialist_names.get(specialist, specialist.title())
            print(f"\n{specialist_name.upper()} ANALYSIS:")
            print("-" * 40)
            analysis_content = analysis.get('analysis', 'No analysis content available')
            # Truncate very long responses for readability
            if len(analysis_content) > 1000:
                print(f"{analysis_content[:1000]}...")
                print(f"\n[Response truncated - showing first 1000 characters of {len(analysis_content)} total]")
            else:
                print(analysis_content)
        print("=" * 60)
        
        # Store results for summary
        technical_test_result = {
            "success": True,
            "execution_time": execution_time,
            "analysis_length": analysis_length,
            "specialists_activated": specialists_activated,
            "routing_reasoning": routing_reasoning,
            "agent_response": technical_results
        }

    except Exception as e:
        print(f"[TEST] Technical Analysis failed: {str(e)}")
        technical_test_result = {"success": False, "error": str(e)}
else:
    print("[TEST] Technical Analysis - SKIPPED (disabled in configuration)")
    quick_test_result = {"success": False, "error": "Test disabled in configuration"}

[TEST] Technical Analysis
Symbol: AAPL
Analysis Type: Technical patterns, indicators, and trends
[ROUTING] Model: gpt-5-mini-2025-08-07 | Tokens: 378 | Context: Routing Decision for AAPL
[ROUTING] Activating TechnicalAnalyst for AAPL
[CACHE] Using cached technical analysis | Symbol: AAPL
Technical Analysis COMPLETED
   Execution Time: 2.78 seconds
   Analysis Length: 6,993 characters
   Specialists Activated: ['technical']

FINAL AGENT RESPONSE:
============================================================
Routing Reasoning: The user explicitly requested detailed technical analysis (chart patterns, indicators, price trends) for AAPL. That falls squarely within the technical specialist's domain. No fundamental, SEC, news, or recommendation specialists are required to fulfill the requested scope; if additional context (recent news, filings, or a buy/sell recommendation) is later requested, those specialists can be engaged.


TECHNICALANALYST ANALYSIS:
----------------------------------------
Summary
- AAPL is trading at 252.29, up ~1.96% on the session and trading slightly below its 52‑week high (259.24). Recent price action shows a short-term uptrend with normal pullbacks and buyers stepping in near the mid‑245 area. Volume today (48.9M) is a bit below the reported average (≈53.8M), suggesting the move is not yet accompanied by strong conviction from a volume perspective.
- Technical bias: short‑term bullish-to-neutral. Price is trading around its short-term moving average zone and below the immediate resistance at the recent swing highs. Manageable supports lie in the 245–238 area; failure below those levels flips the short-term bias toward neutral/bearish.

1) Price trends and patterns
- Trend (short term): Uptrend/rotation — over the most recent 2–6 weeks the stock has made higher lows (roughly low‑245 after a small dip) and recent higher highs around 256–258 before a small consolidation. The last 10 sessions’ simple average is ~251.5 and the current price sits slightl...

[Response truncated - showing first 1000 characters of 5938 total]
============================================================

# Test 4: Fundamental Analysis
if TEST_CONFIG.get("fundamental", True):
    print("[TEST] Fundamental Analysis")
    print(f"Symbol: {TEST_SYMBOL}")
    print("Analysis Type: Financial metrics, valuation, and business performance")

    start_time = time.time()

    try:
        with suppress_llm_logs():
            fundamental_request = f"Analyze {TEST_SYMBOL} fundamentals including financial metrics, valuation, business performance, and competitive position"
            
            fundamental_results = routing_coordinator.route_analysis(fundamental_request, TEST_SYMBOL)
        
        # Calculate metrics
        execution_time = time.time() - start_time
        analysis_length = len(str(fundamental_results))
        specialists_activated = list(fundamental_results.get('specialist_analyses', {}).keys())
        routing_reasoning = fundamental_results.get('routing_decision', {}).get('reasoning', 'N/A')
        
        print(f"Fundamental Analysis COMPLETED")
        print(f"   Execution Time: {execution_time:.2f} seconds")
        print(f"   Analysis Length: {analysis_length:,} characters")
        print(f"   Specialists Activated: {specialists_activated}")
        
        # Print final agent response
        print(f"\nFINAL AGENT RESPONSE:")
        print("=" * 60)
        print(f"Routing Reasoning: {routing_reasoning}")
        print()
        for specialist, analysis in fundamental_results.get('specialist_analyses', {}).items():
            print(f"\n{specialist.upper()} SPECIALIST ANALYSIS:")
            print("-" * 40)
            analysis_content = analysis.get('analysis', 'No analysis content available')
            # Truncate very long responses for readability
            if len(analysis_content) > 1000:
                print(f"{analysis_content[:1000]}...")
                print(f"\n[Response truncated - showing first 1000 characters of {len(analysis_content)} total]")
            else:
                print(analysis_content)
        print("=" * 60)
        
        # Store results for summary
        fundamental_test_result = {
            "success": True,
            "execution_time": execution_time,
            "analysis_length": analysis_length,
            "specialists_activated": specialists_activated,
            "routing_reasoning": routing_reasoning,
            "agent_response": fundamental_results
        }

    except Exception as e:
        print(f"[TEST] Fundamental Analysis failed: {str(e)}")
        fundamental_test_result = {"success": False, "error": str(e)}
else:
    print("[TEST] Fundamental Analysis - SKIPPED (disabled in configuration)")
    quick_test_result = {"success": False, "error": "Test disabled in configuration"}

[TEST] Fundamental Analysis
Symbol: AAPL
Analysis Type: Financial metrics, valuation, and business performance
[ROUTING] Model: gpt-5-mini-2025-08-07 | Tokens: 518 | Context: Routing Decision for AAPL
[ROUTING] Activating FundamentalAnalyst for AAPL
[CACHE] Using cached fundamental analysis | Symbol: AAPL
[ROUTING] Activating SECFilingsAnalyst for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 2102 | Context: SEC Filings Analysis for AAPL
[ROUTING] Activating NewsAnalyst for AAPL
[NEWS CHAIN] Initiating processing pipeline | Symbol: AAPL
[NEWS CHAIN] Step 1: News ingestion
[CACHE] Using cached stock_news data | Symbol: AAPL
[NEWS CHAIN] Step 2: News preprocessing
[NEWS CHAIN] Step 3: News classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 317 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 336 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 334 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 343 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 381 | Context: News Classification
[NEWS CHAIN] Step 4: Insight extraction
[NEWS CHAIN] Model: o4-mini-2025-04-16 | Tokens: 937 | Context: Insights Extraction
[NEWS CHAIN] Step 5: Summary generation
[NEWS CHAIN] Model: gpt-4.1-nano-2025-04-14 | Tokens: 760 | Context: News Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1598 | Context: Sentiment Analysis for AAPL
[ROUTING] Activating InvestmentRecommendationAnalyst for AAPL
[CACHE] Using cached recommendation analysis | Symbol: AAPL
Fundamental Analysis COMPLETED
   Execution Time: 41.12 seconds
   Analysis Length: 38,374 characters
   Specialists Activated: ['fundamental', 'sec', 'news', 'recommendation']

FINAL AGENT RESPONSE:
============================================================
Routing Reasoning: Primary goal is a thorough fundamentals-driven analysis of AAPL (financial metrics, valuation, business performance, competitive position). Start with SEC filings to ensure primary-source accuracy (10-Qs/10-Ks, recent 8-Ks, proxy statements) and capture any material disclosures or accounting changes that affect metrics. Next, have the fundamental specialist perform the financial analysis and valuation using the verified filings and standardized financial data (income statement, balance sheet, cash flows, ratios, segment performance, margins, cash returns, capex, guidance, model inputs). Then route to the news specialist to add recent market-moving developments, product updates, macro/supply-chain issues, and sentiment that could affect short-term outlook or risk assumptions. Finally, send everything to the recommendation specialist to synthesize a clear investment view, integrating the verified filings, quantified fundamentals/valuation, and current news/sentiment into a recommendation and key risks. Technical analysis is not required for this fundamentals-focused request.


FUNDAMENTAL SPECIALIST ANALYSIS:
----------------------------------------
**Fundamental Analysis: Apple Inc. (AAPL)**  
*As of Current Price: $252.29*  

---

### 1. Financial Health Assessment  
Apple Inc. exhibits a robust financial position, underscored by its massive market capitalization of approximately $3.74 trillion, evidencing its status as one of the largest and financially sound technology companies globally. The company’s earnings per share (EPS) stand at $6.58, reflecting solid profitability. While detailed balance sheet data (such as debt levels and cash reserves) is not available here, Apple historically maintains strong liquidity, significant cash holdings, and manageable debt, which supports ongoing R&D, product expansion, and shareholder returns. The volume of ~48.9 million shares traded daily (close to average volume of ~53.96 million) confirms strong market liquidity. Overall, Apple’s financial health remains excellent, positioning it well to withstand economic uncertainties.

---

### 2. Valuation Metrics Analysis  
- **Price/Earnings (P...

[Response truncated - showing first 1000 characters of 6542 total]

SEC SPECIALIST ANALYSIS:
----------------------------------------
Below is a professional regulatory analysis framework for Apple Inc. (AAPL) to support investment decisions, structured around the standard SEC filings (10-K, 10-Q, 8-K) and common disclosure topics. Because the tool to retrieve SEC filings is unavailable in this session, the analysis outlines the key elements you should extract and evaluate from the actual filings when you obtain them.

1) Key regulatory disclosures
- Material risk disclosures:
  - Identify the company’s principal risk factors disclosed in the annual and quarterly reports. Categorize into business/Credit/Market/Operations/Regulatory/regulatory/compliance risks.
  - Assess whether risk factors are increasing, decreasing, or shifting (e.g., exposure to geopolitical tensions, supply chain constraints, regulatory scrutiny of App Store practices, data privacy requirements).
- Legal and regulatory proceedings:
  - Note ongoing litigation, settlements, or investigations (antitrust, patent, product liability, securities-relat...

[Response truncated - showing first 1000 characters of 9571 total]

NEWS SPECIALIST ANALYSIS:
----------------------------------------
Overall sentiment assessment
- Net tone: Mildly positive-to-neutral. Several articles emphasize improved profitability (margins, EPS) driven by buybacks — a clear positive — while product commentary (e.g., foldable phone “won’t move the needle”) tempers expectations for near‑term revenue catalysts. No headlines indicate major negative surprises (recalls, regulatory shocks, or sharp demand collapse).
- Confidence: Moderate. The positive signals are concrete (earnings per share improvements, capital return programs), but product/innovation stories and single-analyst takes introduce uncertainty about future growth drivers.

Market perception trends
- Income/return-focused view: Market narrative is shifting toward Apple as a high-quality cash-generative company that returns capital to shareholders (buybacks/dividends) and is improving margins — attractive to income and value-seeking investors.
- Slower growth narrative persists: Analysts and some media continue to portray hardware innovati...

[Response truncated - showing first 1000 characters of 5881 total]

RECOMMENDATION SPECIALIST ANALYSIS:
----------------------------------------
Investment Recommendation: Apple Inc. (AAPL)

Current Price: 252.29 USD

1) Investment Thesis
- Durable competitive position: Apple remains a leader in hardware quality, ecosystem lock-in (iOS/macOS services), and brand strength. Services and wearables continue to offer higher-margin growth that complements hardware cycles.
- Revenue resilience with product cycle upside: While iPhone remains the primary driver, Services, Wearables, and Mac/Other categories provide diversification and margin expansion potential, supporting cash flow stability in a higher-rate environment.
- Balance sheet and capital returns: Generous buyback program and dividend support shareholder value while maintaining capacity to invest in R&D, platform ecosystems, and strategic acquisitions if opportunities arise.
- Modest near-term macro headwinds but supportive long-term growth: Macro pressures exist (tightening consumer spend, supply chain dynamics), yet Apple’s pricing power and ecosystem moat help mitigate mar...

[Response truncated - showing first 1000 characters of 5235 total]
============================================================

# Test 5: News & Sentiment Analysis
if TEST_CONFIG.get("news_sentiment", True):
    print("[TEST] News & Sentiment Analysis")
    print(f"Symbol: {TEST_SYMBOL}")
    print("Analysis Type: News coverage and market sentiment")

    start_time = time.time()

    try:
        with suppress_llm_logs():
            news_request = f"Analyze recent news and market sentiment for {TEST_SYMBOL} including media coverage and investor sentiment"
            
            # Run routing analysis for news
            news_results = routing_coordinator.route_analysis(news_request, TEST_SYMBOL)
            
            # Also test news processing chain directly
            news_articles = news_chain.ingest_news(TEST_SYMBOL)
            news_analysis = news_chain.process_news_chain(TEST_SYMBOL)
        
        # Calculate metrics
        execution_time = time.time() - start_time
        analysis_length = len(str(news_results))
        specialists_activated = list(news_results.get('specialist_analyses', {}).keys())
        articles_processed = len(news_articles)
        news_chain_analysis_length = len(str(news_analysis))
        
        print(f"[TEST] News & Sentiment Analysis completed | Time: {execution_time:.2f}s | Length: {analysis_length:,} chars | Articles: {articles_processed}")
        
        # Print final agent response
        print(f"\nFINAL AGENT RESPONSE:")
        print("=" * 60)
        print(f"Articles Found: {articles_processed}")
        print()
        for specialist, analysis in news_results.get('specialist_analyses', {}).items():
            print(f"\n{specialist.upper()} SPECIALIST ANALYSIS:")
            print("-" * 40)
            analysis_content = analysis.get('analysis', 'No analysis content available')
            # Truncate very long responses for readability
            if len(analysis_content) > 1000:
                print(f"{analysis_content[:1000]}...")
                print(f"\n[Response truncated - showing first 1000 characters of {len(analysis_content)} total]")
            else:
                print(analysis_content)
        
        print(f"\nNEWS PROCESSING CHAIN ANALYSIS:")
        print("-" * 40)
        news_analysis_str = str(news_analysis)
        if len(news_analysis_str) > 1000:
            print(f"{news_analysis_str[:1000]}...")
            print(f"\n[Analysis truncated - showing first 1000 characters of {len(news_analysis_str)} total]")
        else:
            print(news_analysis_str)
        print("=" * 60)
        
        # Store results for summary
        news_test_result = {
            "success": True,
            "execution_time": execution_time,
            "analysis_length": analysis_length,
            "specialists_activated": specialists_activated,
            "articles_processed": articles_processed,
            "news_chain_analysis": news_chain_analysis_length,
            "agent_response": news_results,
            "news_chain_response": news_analysis
        }

    except Exception as e:
        print(f"[TEST] News & Sentiment Analysis failed: {str(e)}")
        news_test_result = {"success": False, "error": str(e)}
else:
    print("[TEST] News & Sentiment Analysis - SKIPPED (disabled in configuration)")
    quick_test_result = {"success": False, "error": "Test disabled in configuration"}

[TEST] News & Sentiment Analysis
Symbol: AAPL
Analysis Type: News coverage and market sentiment
[ROUTING] Model: gpt-5-mini-2025-08-07 | Tokens: 409 | Context: Routing Decision for AAPL
[ROUTING] Activating NewsAnalyst for AAPL
[NEWS CHAIN] Initiating processing pipeline | Symbol: AAPL
[NEWS CHAIN] Step 1: News ingestion
[CACHE] Using cached stock_news data | Symbol: AAPL
[NEWS CHAIN] Step 2: News preprocessing
[NEWS CHAIN] Step 3: News classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 326 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 346 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 334 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 278 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 325 | Context: News Classification
[NEWS CHAIN] Step 4: Insight extraction
[NEWS CHAIN] Model: o4-mini-2025-04-16 | Tokens: 936 | Context: Insights Extraction
[NEWS CHAIN] Step 5: Summary generation
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 895 | Context: News Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1732 | Context: Sentiment Analysis for AAPL
[ROUTING] Activating TechnicalAnalyst for AAPL
[CACHE] Using cached technical analysis | Symbol: AAPL
[ROUTING] Activating FundamentalAnalyst for AAPL
[CACHE] Using cached fundamental analysis | Symbol: AAPL
[ROUTING] Activating InvestmentRecommendationAnalyst for AAPL
[CACHE] Using cached recommendation analysis | Symbol: AAPL
[CACHE] Using cached stock_news data | Symbol: AAPL
[NEWS CHAIN] Initiating processing pipeline | Symbol: AAPL
[NEWS CHAIN] Step 1: News ingestion
[CACHE] Using cached stock_news data | Symbol: AAPL
[NEWS CHAIN] Step 2: News preprocessing
[NEWS CHAIN] Step 3: News classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 320 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 344 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 336 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 347 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 338 | Context: News Classification
[NEWS CHAIN] Step 4: Insight extraction
[NEWS CHAIN] Model: o4-mini-2025-04-16 | Tokens: 952 | Context: Insights Extraction
[NEWS CHAIN] Step 5: Summary generation
[NEWS CHAIN] Model: gpt-4.1-nano-2025-04-14 | Tokens: 786 | Context: News Summary for AAPL
[TEST] News & Sentiment Analysis completed | Time: 46.18s | Length: 34,977 chars | Articles: 5

FINAL AGENT RESPONSE:
============================================================
Articles Found: 5


NEWS SPECIALIST ANALYSIS:
----------------------------------------
Enhanced Sentiment Analysis — AAPL

Summary judgment
Overall sentiment across the processed coverage is mildly positive-to-neutral. The highest‑importance item (Forbes) frames Apple’s share buybacks and margin/eps improvement as constructive despite middling revenue growth, while other coverage (e.g., analyst commentary on a foldable phone) tempers enthusiasm by signaling limited product upside. Net effect: supportive fundamentals (cash returns and margins) with a need for clearer growth catalysts to materially re‑rate the stock.

1) Overall sentiment assessment
- Tone: Mildly positive. Primary drivers of positive tone are margin expansion, improved EPS via buybacks, and a resilient business model (installed base + services). Counterbalancing views are product‑cycle skepticism and commentary that new hardware (e.g., a foldable phone) may not materially change growth trajectories.
- Strength: The most consequential article is positive and rated high importance; less consequential pieces...

[Response truncated - showing first 1000 characters of 5957 total]

TECHNICAL SPECIALIST ANALYSIS:
----------------------------------------
Summary
- AAPL is trading at 252.29, up ~1.96% on the session and trading slightly below its 52‑week high (259.24). Recent price action shows a short-term uptrend with normal pullbacks and buyers stepping in near the mid‑245 area. Volume today (48.9M) is a bit below the reported average (≈53.8M), suggesting the move is not yet accompanied by strong conviction from a volume perspective.
- Technical bias: short‑term bullish-to-neutral. Price is trading around its short-term moving average zone and below the immediate resistance at the recent swing highs. Manageable supports lie in the 245–238 area; failure below those levels flips the short-term bias toward neutral/bearish.

1) Price trends and patterns
- Trend (short term): Uptrend/rotation — over the most recent 2–6 weeks the stock has made higher lows (roughly low‑245 after a small dip) and recent higher highs around 256–258 before a small consolidation. The last 10 sessions’ simple average is ~251.5 and the current price sits slightl...

[Response truncated - showing first 1000 characters of 5938 total]

FUNDAMENTAL SPECIALIST ANALYSIS:
----------------------------------------
**Fundamental Analysis: Apple Inc. (AAPL)**  
*As of Current Price: $252.29*  

---

### 1. Financial Health Assessment  
Apple Inc. exhibits a robust financial position, underscored by its massive market capitalization of approximately $3.74 trillion, evidencing its status as one of the largest and financially sound technology companies globally. The company’s earnings per share (EPS) stand at $6.58, reflecting solid profitability. While detailed balance sheet data (such as debt levels and cash reserves) is not available here, Apple historically maintains strong liquidity, significant cash holdings, and manageable debt, which supports ongoing R&D, product expansion, and shareholder returns. The volume of ~48.9 million shares traded daily (close to average volume of ~53.96 million) confirms strong market liquidity. Overall, Apple’s financial health remains excellent, positioning it well to withstand economic uncertainties.

---

### 2. Valuation Metrics Analysis  
- **Price/Earnings (P...

[Response truncated - showing first 1000 characters of 6542 total]

RECOMMENDATION SPECIALIST ANALYSIS:
----------------------------------------
Investment Recommendation: Apple Inc. (AAPL)

Current Price: 252.29 USD

1) Investment Thesis
- Durable competitive position: Apple remains a leader in hardware quality, ecosystem lock-in (iOS/macOS services), and brand strength. Services and wearables continue to offer higher-margin growth that complements hardware cycles.
- Revenue resilience with product cycle upside: While iPhone remains the primary driver, Services, Wearables, and Mac/Other categories provide diversification and margin expansion potential, supporting cash flow stability in a higher-rate environment.
- Balance sheet and capital returns: Generous buyback program and dividend support shareholder value while maintaining capacity to invest in R&D, platform ecosystems, and strategic acquisitions if opportunities arise.
- Modest near-term macro headwinds but supportive long-term growth: Macro pressures exist (tightening consumer spend, supply chain dynamics), yet Apple’s pricing power and ecosystem moat help mitigate mar...

[Response truncated - showing first 1000 characters of 5235 total]

NEWS PROCESSING CHAIN ANALYSIS:
----------------------------------------
{'symbol': 'AAPL', 'raw_articles_count': 5, 'processed_articles_count': 5, 'classified_articles': [{'title': 'Buy Or Sell Apple Stock?', 'description': 'While Apple’s growth has been middling in recent years, the company has bolstered its margins and improved per share earnings, driven by share buybacks', 'source': 'Forbes', 'published_at': '2025-10-16T13:01:33Z', 'url': 'https://www.forbes.com/sites/greatspeculations/2025/10/16/buy-or-sell-apple-stock/', 'combined_text': 'Buy Or Sell Apple Stock? While Apple’s growth has been middling in recent years, the company has bolstered its margins and improved per share earnings, driven by share buybacks', 'category': 'earnings', 'sentiment': 'positive', 'importance': 'high', 'reasoning': 'The article emphasizes improved per-share earnings and margins driven by share buybacks, indicating a favorable view on earnings performance despite middling overall growth.', 'model_used': 'gpt-5-nano-2025-08-07'}, {'title': 'Analyst Says Apple (AAPL) Folda...

[Analysis truncated - showing first 1000 characters of 8332 total]
============================================================

# Test 6: Investment Recommendation Analysis
if TEST_CONFIG.get("investment_recommendation", True):
    print("[TEST] Investment Recommendation Analysis")
    print(f"Symbol: {TEST_SYMBOL}")
    print("Analysis Type: Investment recommendations with buy/sell/hold ratings")

    start_time = time.time()

    try:
        with suppress_llm_logs():
            recommendation_request = f"Provide detailed investment recommendation for {TEST_SYMBOL} including buy/sell/hold rating, target price, and confidence level"
            
            # Run routing analysis for investment recommendation
            recommendation_results = routing_coordinator.route_analysis(recommendation_request, TEST_SYMBOL)
            
            # Also test the investment recommendation tool directly
            direct_recommendation = get_investment_recommendation.invoke({"symbol": TEST_SYMBOL, "analysis_context": "Standalone recommendation test"})
        
        # Calculate metrics
        execution_time = time.time() - start_time
        analysis_length = len(str(recommendation_results))
        specialists_activated = list(recommendation_results.get('specialist_analyses', {}).keys())
        routing_reasoning = recommendation_results.get('routing_decision', {}).get('reasoning', 'N/A')
        
        # Extract recommendation details if available
        recommendation_specialist_data = recommendation_results.get('specialist_analyses', {}).get('recommendation', {})
        investment_recommendation = recommendation_specialist_data.get('recommendation', 'N/A')
        confidence_level = recommendation_specialist_data.get('confidence', 'N/A')
        target_price = recommendation_specialist_data.get('target_price', 'N/A')
        current_price = recommendation_specialist_data.get('current_price', 'N/A')
        risk_level = recommendation_specialist_data.get('risk_level', 'N/A')
        
        print(f"Investment Recommendation Analysis COMPLETED")
        print(f"   Execution Time: {execution_time:.2f} seconds")
        print(f"   Analysis Length: {analysis_length:,} characters")
        print(f"   Specialists Activated: {specialists_activated}")
        print(f"   Investment Recommendation: {investment_recommendation}")
        print(f"   Confidence Level: {confidence_level}")
        print(f"   Target Price: ${target_price}")
        print(f"   Current Price: ${current_price}")
        print(f"   Risk Level: {risk_level}")
        
        # Print ONLY the direct recommendation tool output as agent response
        print(f"\nFINAL AGENT RESPONSE (DIRECT RECOMMENDATION TOOL OUTPUT ONLY):")
        print("=" * 60)
        
        try:
            direct_rec_data = json.loads(direct_recommendation)
            print(f"RECOMMENDATION: {direct_rec_data.get('recommendation', 'N/A')}")
            print(f"CONFIDENCE: {direct_rec_data.get('confidence', 'N/A')}")
            print(f"SCORE: {direct_rec_data.get('recommendation_score', 'N/A')}/100")
            print(f"TARGET PRICE: ${direct_rec_data.get('target_price', 'N/A')}")
            print(f"CURRENT PRICE: ${direct_rec_data.get('current_price', 'N/A')}")
            print(f"RISK LEVEL: {direct_rec_data.get('risk_level', 'N/A')}")
            print(f"KEY FACTORS: {', '.join(direct_rec_data.get('key_factors', ['N/A'])[:5])}")
            
            # Show the full recommendation reasoning if available
            if 'reasoning' in direct_rec_data:
                print(f"\nREASONING:")
                print(direct_rec_data['reasoning'])
                
        except Exception as parse_error:
            print("Failed to parse direct recommendation data, showing raw output:")
            print(direct_recommendation)
        
        print("=" * 60)
        
        # Store results for summary
        recommendation_test_result = {
            "success": True,
            "execution_time": execution_time,
            "analysis_length": analysis_length,
            "specialists_activated": specialists_activated,
            "routing_reasoning": routing_reasoning,
            "investment_recommendation": investment_recommendation,
            "confidence_level": confidence_level,
            "target_price": target_price,
            "current_price": current_price,
            "risk_level": risk_level,
            "agent_response": recommendation_results,
            "direct_recommendation": direct_recommendation
        }

    except Exception as e:
        print(f"[TEST] Investment Recommendation Analysis failed: {str(e)}")
        recommendation_test_result = {"success": False, "error": str(e)}
else:
    print("[TEST] News & Sentiment Analysis - SKIPPED (disabled in configuration)")
    quick_test_result = {"success": False, "error": "Test disabled in configuration"}

[TEST] Investment Recommendation Analysis
Symbol: AAPL
Analysis Type: Investment recommendations with buy/sell/hold ratings
[ROUTING] Model: gpt-5-mini-2025-08-07 | Tokens: 451 | Context: Routing Decision for AAPL
[ROUTING] Activating SECFilingsAnalyst for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 2632 | Context: SEC Filings Analysis for AAPL
[ROUTING] Activating NewsAnalyst for AAPL
[NEWS CHAIN] Initiating processing pipeline | Symbol: AAPL
[NEWS CHAIN] Step 1: News ingestion
[CACHE] Using cached stock_news data | Symbol: AAPL
[NEWS CHAIN] Step 2: News preprocessing
[NEWS CHAIN] Step 3: News classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 316 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 267 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 264 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 289 | Context: News Classification
[NEWS CHAIN] Model: gpt-5-nano-2025-08-07 | Tokens: 339 | Context: News Classification
[NEWS CHAIN] Step 4: Insight extraction
[NEWS CHAIN] Model: gpt-5-mini-2025-08-07 | Tokens: 1089 | Context: Insights Extraction
[NEWS CHAIN] Step 5: Summary generation
[NEWS CHAIN] Model: gpt-5-mini-2025-08-07 | Tokens: 1185 | Context: News Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1840 | Context: Sentiment Analysis for AAPL
[ROUTING] Activating FundamentalAnalyst for AAPL
[CACHE] Using cached fundamental analysis | Symbol: AAPL
[ROUTING] Activating TechnicalAnalyst for AAPL
[CACHE] Using cached technical analysis | Symbol: AAPL
[ROUTING] Activating InvestmentRecommendationAnalyst for AAPL
[CACHE] Using cached recommendation analysis | Symbol: AAPL
Gathering data for investment recommendation on AAPL...
[CACHE] Using cached stock_data data | Symbol: AAPL
[CACHE] Using cached alpha_vantage data | Symbol: AAPL
[DATA] Economic data cached for FEDFUNDS
[CACHE] Stored economic_data data | Symbol: FEDFUNDS
[DATA] Investment recommendation generated for AAPL
[CACHE] Stored investment_recommendation data | Symbol: AAPL
Investment Recommendation Analysis COMPLETED
   Execution Time: 59.75 seconds
   Analysis Length: 49,537 characters
   Specialists Activated: ['sec', 'news', 'fundamental', 'technical', 'recommendation']
   Investment Recommendation: Hold
   Confidence Level: Medium
   Target Price: $0
   Current Price: $0
   Risk Level: Medium

FINAL AGENT RESPONSE (DIRECT RECOMMENDATION TOOL OUTPUT ONLY):
============================================================
RECOMMENDATION: Hold
CONFIDENCE: Medium
SCORE: 48/100
TARGET PRICE: $252.29
CURRENT PRICE: $252.29
RISK LEVEL: Low
KEY FACTORS: Trading near 52-week high - limited upside, Low interest rates supportive
============================================================

# Testing Summary & Results
print("INVESTMENT RESEARCH AGENT - TEST RESULTS SUMMARY")
print("=" * 70)
print(f"Test Symbol: {TEST_SYMBOL} (Apple Inc.)")
print("=" * 70)

# Collect all test results
test_results = {}

# Check if test results exist (they should be defined from running the individual tests)
try:
    test_results["comprehensive"] = comprehensive_test_result
except NameError:
    test_results["comprehensive"] = {"success": False, "error": "Test not run"}

try:
    test_results["technical"] = technical_test_result
except NameError:
    test_results["technical"] = {"success": False, "error": "Test not run"}

try:
    test_results["fundamental"] = fundamental_test_result
except NameError:
    test_results["fundamental"] = {"success": False, "error": "Test not run"}

try:
    test_results["news_sentiment"] = news_test_result
except NameError:
    test_results["news_sentiment"] = {"success": False, "error": "Test not run"}

try:
    test_results["quick"] = quick_test_result
except NameError:
    test_results["quick"] = {"success": False, "error": "Test not run"}

try:
    test_results["investment_recommendation"] = recommendation_test_result
except NameError:
    test_results["investment_recommendation"] = {"success": False, "error": "Test not run"}

# Calculate summary statistics
total_tests = len(test_results)
successful_tests = sum(1 for r in test_results.values() if r.get('success', False))
success_rate = (successful_tests/total_tests)*100 if total_tests > 0 else 0

# Display overall summary
print(f"OVERALL RESULTS:")
print(f"   Total Tests: {total_tests}")
print(f"   Successful: {successful_tests}")
print(f"   Success Rate: {success_rate:.1f}%")

status = "ALL SYSTEMS OPERATIONAL" if success_rate == 100 else "SOME ISSUES DETECTED" if success_rate >= 50 else "SYSTEM ISSUES"
print(f"   Status: {status}")

# Display individual test results
print(f"\nDETAILED RESULTS:")
print("-" * 70)

for test_name, result in test_results.items():
    status_text = "PASS" if result.get('success', False) else "FAIL"
    exec_time = result.get('execution_time', 0)
    
    test_display_name = test_name.replace('_', ' ').title()
    print(f"{test_display_name:<25} {status_text:<8} ({exec_time:>6.2f}s)")
    
    if result.get('success', False):
        # Show specific metrics for each test type
        if test_name == "comprehensive":
            quality = result.get('quality_score', 'N/A')
            specialists = result.get('specialists_used', 0)
            cycles = result.get('optimization_cycles', 0)
            print(f"     Quality Score: {quality}/10  |  Specialists: {specialists}  |  Opt Cycles: {cycles}")
        
        elif test_name in ["technical", "fundamental", "quick"]:
            specialists = result.get('specialists_activated', [])
            length = result.get('analysis_length', 0)
            print(f"     Specialists: {specialists}  |  Analysis: {length:,} chars")
        
        elif test_name == "news_sentiment":
            specialists = result.get('specialists_activated', [])
            articles = result.get('articles_processed', 0)
            print(f"     Specialists: {specialists}  |  Articles: {articles}")
        
        elif test_name == "investment_recommendation":
            specialists = result.get('specialists_activated', [])
            recommendation = result.get('investment_recommendation', 'N/A')
            confidence = result.get('confidence_level', 'N/A')
            print(f"     Specialists: {specialists}  |  Recommendation: {recommendation} ({confidence})")
    
    else:
        error_msg = result.get('error', 'Unknown error')
        print(f"     Error: {error_msg[:50]}...")

# Show performance statistics
print(f"\nPERFORMANCE METRICS:")
print("-" * 70)

execution_times = [r.get('execution_time', 0) for r in test_results.values() if r.get('success', False)]
if execution_times:
    avg_time = sum(execution_times) / len(execution_times)
    max_time = max(execution_times)
    min_time = min(execution_times)
    
    print(f"   Average Execution Time: {avg_time:.2f} seconds")
    print(f"   Fastest Test: {min_time:.2f} seconds")
    print(f"   Slowest Test: {max_time:.2f} seconds")
    print(f"   Total Execution Time: {sum(execution_times):.2f} seconds")

print(f"\n" + "=" * 70)
print("[SYSTEM] Testing completed - Ready for investment analysis")
print("=" * 70)

INVESTMENT RESEARCH AGENT - TEST RESULTS SUMMARY
======================================================================
Test Symbol: AAPL (Apple Inc.)
======================================================================
OVERALL RESULTS:
   Total Tests: 6
   Successful: 6
   Success Rate: 100.0%
   Status: ALL SYSTEMS OPERATIONAL

DETAILED RESULTS:
----------------------------------------------------------------------
Comprehensive             PASS     ( 75.70s)
     Quality Score: 7/10  |  Specialists: 5  |  Opt Cycles: 1
Technical                 PASS     (  2.78s)
     Specialists: ['technical']  |  Analysis: 6,993 chars
Fundamental               PASS     ( 41.12s)
     Specialists: ['fundamental', 'sec', 'news', 'recommendation']  |  Analysis: 38,374 chars
News Sentiment            PASS     ( 46.18s)
     Specialists: ['news', 'technical', 'fundamental', 'recommendation']  |  Articles: 5
Quick                     PASS     (101.17s)
     Specialists: ['fundamental', 'news', 'sec', 'technical', 'recommendation']  |  Analysis: 44,266 chars
Investment Recommendation PASS     ( 59.75s)
     Specialists: ['sec', 'news', 'fundamental', 'technical', 'recommendation']  |  Recommendation: Hold (Medium)

PERFORMANCE METRICS:
----------------------------------------------------------------------
   Average Execution Time: 54.45 seconds
   Fastest Test: 2.78 seconds
   Slowest Test: 101.17 seconds
   Total Execution Time: 326.70 seconds

======================================================================
[SYSTEM] Testing completed - Ready for investment analysis
======================================================================

def calculate_quality_score(result, test_name):
    """Calculate a quality score based on test results and characteristics"""
    try:
        score = 0
        
        # Base score for successful execution
        if result.get('success', False):
            score += 3
        
        # Score based on analysis length (content richness)
        analysis_length = result.get('analysis_length', 0)
        if analysis_length > 50000:
            score += 3  # Very comprehensive
        elif analysis_length > 30000:
            score += 2  # Good depth
        elif analysis_length > 10000:
            score += 1  # Basic coverage
        
        # Score based on specialists activated (analysis breadth)
        specialists = result.get('specialists_activated', result.get('specialists_used', []))
        specialist_count = len(specialists) if isinstance(specialists, list) else (specialists if specialists else 0)
        
        if specialist_count >= 4:
            score += 2  # Full multi-agent analysis
        elif specialist_count >= 3:
            score += 1  # Good coverage
        elif specialist_count >= 2:
            score += 0.5  # Partial coverage
        
        # Score based on execution efficiency (reasonable time)
        exec_time = result.get('execution_time', 0)
        if exec_time > 0:
            if exec_time < 180:  # Under 3 minutes
                score += 1
            elif exec_time < 300:  # Under 5 minutes
                score += 0.5
        
        # Bonus for specific test characteristics
        if test_name == 'News & Sentiment':
            articles = result.get('articles_processed', 0)
            if articles >= 5:
                score += 1
            elif articles >= 3:
                score += 0.5
        
        if test_name == 'Comprehensive':
            cycles = result.get('optimization_cycles', 0)
            if cycles > 0:
                score += 1
        
        if test_name == 'Investment Recommendation' or test_name == 'investment_recommendation':
            # Score based on recommendation quality
            recommendation = result.get('investment_recommendation', '')
            confidence = result.get('confidence_level', '')
            target_price = result.get('target_price', None)
            
            if recommendation and recommendation != 'N/A':
                score += 1  # Valid recommendation provided
            if confidence in ['High', 'Medium']:
                score += 0.5  # Reasonable confidence level
            if target_price and target_price != 'N/A':
                try:
                    price_val = float(target_price) if isinstance(target_price, str) else target_price
                    if price_val > 0:
                        score += 0.5  # Valid target price provided
                except:
                    pass
        
        # Cap the score at 10
        return min(round(score, 1), 10.0)
        
    except Exception as e:
        print(f"Error calculating quality score for {test_name}: {e}")
        return 5.0  # Default fallback score

def capture_evaluation_scores():
    """Capture and structure evaluation scores from test results"""
    
    # Initialize scores dictionary
    scores = {
        'test_name': [],
        'success': [],
        'execution_time': [],
        'quality_score': [],
        'analysis_length': [],
        'specialists_count': [],
        'articles_processed': [],
        'optimization_cycles': []
    }
    
    # Check if test results exist and capture scores
    test_mapping = {
        'Quick Analysis': 'quick_test_result',
        'Comprehensive': 'comprehensive_test_result',
        'Technical': 'technical_test_result', 
        'Fundamental': 'fundamental_test_result',
        'News & Sentiment': 'news_test_result',
        'Investment Recommendation': 'recommendation_test_result'
    }
    
    for test_name, var_name in test_mapping.items():
        try:
            # Get the test result variable
            result = globals().get(var_name, {})
            
            if result.get('success', False):
                scores['test_name'].append(test_name)
                scores['success'].append(1)
                scores['execution_time'].append(result.get('execution_time', 0))
                
                # Quality score calculation
                if 'quality_score' in result and result['quality_score'] is not None:
                    scores['quality_score'].append(result['quality_score'])
                else:
                    # Calculate quality score based on available metrics
                    calculated_quality = calculate_quality_score(result, test_name)
                    scores['quality_score'].append(calculated_quality)
                
                # Analysis length - handle different field names for different test types
                analysis_length = result.get('analysis_length', 0)
                if analysis_length == 0 and 'report_length' in result:
                    # For comprehensive tests that use report_length instead
                    analysis_length = result.get('report_length', 0)
                scores['analysis_length'].append(analysis_length)
                
                # Count specialists
                specialists = result.get('specialists_activated', result.get('specialists_used', []))
                if isinstance(specialists, list):
                    scores['specialists_count'].append(len(specialists))
                else:
                    scores['specialists_count'].append(specialists if specialists else 0)
                
                # Articles processed (only for news analysis)
                scores['articles_processed'].append(result.get('articles_processed', 0))
                
                # Optimization cycles (only for comprehensive)
                scores['optimization_cycles'].append(result.get('optimization_cycles', 0))
            
            else:
                # Failed test - calculate minimal quality score
                failed_result = {'success': False, 'execution_time': 0, 'analysis_length': 0}
                failed_quality = calculate_quality_score(failed_result, test_name)
                
                scores['test_name'].append(test_name)
                scores['success'].append(0)
                scores['execution_time'].append(0)
                scores['quality_score'].append(failed_quality)  # Use calculated score instead of None
                scores['analysis_length'].append(0)
                scores['specialists_count'].append(0)
                scores['articles_processed'].append(0)
                scores['optimization_cycles'].append(0)
                
        except Exception as e:
            print(f"Error capturing scores for {test_name}: {e}")
            continue
    
    # Convert to DataFrame
    df = pd.DataFrame(scores)
    return df

# Capture the evaluation scores
scores_df = capture_evaluation_scores()
print("Evaluation Scores Captured:")
print(scores_df)

# Store timestamp for tracking
test_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"\nTest Results Captured at: {test_timestamp}")

Evaluation Scores Captured:
                   test_name  success  execution_time  quality_score  \
0             Quick Analysis        1      101.170903            8.0   
1              Comprehensive        1       75.700119            7.0   
2                  Technical        1        2.781285            4.0   
3                Fundamental        1       41.123772            8.0   
4           News & Sentiment        1       46.175062            9.0   
5  Investment Recommendation        1       59.747600            9.5   

   analysis_length  specialists_count  articles_processed  optimization_cycles  
0            44266                  5                   0                    0  
1            11643                  5                   0                    1  
2             6993                  1                   0                    0  
3            38374                  4                   0                    0  
4            34977                  4                   5                    0  
5            49537                  5                   0                    0  

Test Results Captured at: 2025-10-19 01:12:39

# Create comprehensive performance visualization and charts
def create_performance_charts(scores_df, test_results):
    """
    Create comprehensive performance visualization charts for all test results.
    """
    import matplotlib.pyplot as plt
    import seaborn as sns
    import numpy as np
    from matplotlib.patches import Rectangle
    import warnings
    warnings.filterwarnings('ignore')
    
    # Set style for better looking charts
    plt.style.use('default')
    sns.set_palette("husl")
    
    # Create figure with subplots (2x2 grid instead of 3x2)
    fig, axes = plt.subplots(2, 2, figsize=(14, 12))
    fig.suptitle('Investment Research Agent - Performance Dashboard', fontsize=10, fontweight='bold', y=0.98)
    
    # 1. Test Success Rate (Top Left)
    ax1 = axes[0, 0]
    if not scores_df.empty:
        success_counts = scores_df['success'].value_counts()
        colors = ['lightgreen' if x == 1 else 'lightcoral' for x in success_counts.index]
        wedges, texts, autotexts = ax1.pie(success_counts.values, 
                                          labels=['Success' if x == 1 else 'Failed' for x in success_counts.index],
                                          colors=colors, autopct='%1.1f%%', startangle=90)
        ax1.set_title('Test Success Rate', fontsize=14, fontweight='bold')
        
        # Add success rate text
        success_rate = (scores_df['success'].sum() / len(scores_df)) * 100
        ax1.text(0, -1.3, f'Overall Success Rate: {success_rate:.1f}%', 
                ha='center', fontsize=12, fontweight='bold')
    else:
        ax1.text(0.5, 0.5, 'No Test Data Available', ha='center', va='center', transform=ax1.transAxes)
        ax1.set_title('Test Success Rate', fontsize=14, fontweight='bold')
    
    # 2. Execution Times by Test (Top Right)
    ax2 = axes[0, 1]
    if not scores_df.empty and 'execution_time' in scores_df.columns:
        test_names = scores_df['test_name'].tolist()
        exec_times = scores_df['execution_time'].tolist()
        
        bars = ax2.bar(range(len(test_names)), exec_times, 
                      color=['green' if s == 1 else 'red' for s in scores_df['success']])
        ax2.set_xlabel('Test Type')
        ax2.set_ylabel('Execution Time (seconds)')
        ax2.set_title('Execution Time by Test Type', fontsize=14, fontweight='bold')
        ax2.set_xticks(range(len(test_names)))
        ax2.set_xticklabels([name.replace('_', ' ').title() for name in test_names], rotation=45, ha='right')
        
        # Add value labels on bars
        for i, (bar, time) in enumerate(zip(bars, exec_times)):
            height = bar.get_height()
            ax2.text(bar.get_x() + bar.get_width()/2., height + 0.1,
                    f'{time:.1f}s', ha='center', va='bottom', fontsize=10)
    else:
        ax2.text(0.5, 0.5, 'No Execution Time Data', ha='center', va='center', transform=ax2.transAxes)
        ax2.set_title('Execution Time by Test Type', fontsize=14, fontweight='bold')
    
    # 3. Quality Scores Comparison (Bottom Left) - Changed to vertical bars and scale to 10
    ax3 = axes[1, 0]
    if not scores_df.empty and 'quality_score' in scores_df.columns:
        test_names = scores_df['test_name'].tolist()
        quality_scores = scores_df['quality_score'].tolist()
        
        bars = ax3.bar(range(len(test_names)), quality_scores, 
                       color=['darkgreen' if s == 1 else 'darkred' for s in scores_df['success']])
        ax3.set_xlabel('Test Type')
        ax3.set_ylabel('Quality Score')
        ax3.set_title('Quality Scores by Test Type', fontsize=14, fontweight='bold')
        ax3.set_xticks(range(len(test_names)))
        ax3.set_xticklabels([name.replace('_', ' ').title() for name in test_names], rotation=45, ha='right')
        ax3.set_ylim(0, 10)
        
        # Add value labels on bars
        for i, (bar, score) in enumerate(zip(bars, quality_scores)):
            height = bar.get_height()
            ax3.text(bar.get_x() + bar.get_width()/2., height + 0.1,
                    f'{score:.1f}', ha='center', va='bottom', fontsize=10)
    else:
        ax3.text(0.5, 0.5, 'No Quality Score Data', ha='center', va='center', transform=ax3.transAxes)
        ax3.set_title('Quality Scores by Test Type', fontsize=14, fontweight='bold')
    
    # 4. Analysis Length Distribution (Bottom Right)
    ax4 = axes[1, 1]
    if not scores_df.empty and 'analysis_length' in scores_df.columns:
        test_names = scores_df['test_name'].tolist()
        analysis_lengths = scores_df['analysis_length'].tolist()
        
        bars = ax4.bar(range(len(test_names)), analysis_lengths,
                      color=['blue' if s == 1 else 'orange' for s in scores_df['success']])
        ax4.set_xlabel('Test Type')
        ax4.set_ylabel('Analysis Length (characters)')
        ax4.set_title('Analysis Depth by Test Type', fontsize=14, fontweight='bold')
        ax4.set_xticks(range(len(test_names)))
        ax4.set_xticklabels([name.replace('_', ' ').title() for name in test_names], rotation=45, ha='right')
        
        # Add value labels on bars
        for i, (bar, length) in enumerate(zip(bars, analysis_lengths)):
            height = bar.get_height()
            ax4.text(bar.get_x() + bar.get_width()/2., height + max(analysis_lengths)*0.01,
                    f'{length:,}', ha='center', va='bottom', fontsize=9, rotation=90)
    else:
        ax4.text(0.5, 0.5, 'No Analysis Length Data', ha='center', va='center', transform=ax4.transAxes)
        ax4.set_title('Analysis Depth by Test Type', fontsize=14, fontweight='bold')
    
    plt.tight_layout()
    plt.subplots_adjust(top=0.95, hspace=0.3, wspace=0.3)
    
    return fig

# Generate the performance charts
try:
    # Configure matplotlib for Jupyter notebook display
    import matplotlib
    matplotlib.use('inline')
    import matplotlib.pyplot as plt
    
    # Enable inline plotting
    from IPython.display import display
    
    performance_fig = create_performance_charts(scores_df, test_results)
    
    # Display the figure properly in Jupyter
    display(performance_fig)
    
    # Additional performance insights
    if not scores_df.empty:
        best_performer = scores_df.loc[scores_df['quality_score'].idxmax(), 'test_name'] if 'quality_score' in scores_df.columns else "N/A"
        fastest_test = scores_df.loc[scores_df['execution_time'].idxmin(), 'test_name'] if 'execution_time' in scores_df.columns else "N/A"
        
        print(f"Best Quality: {best_performer.replace('_', ' ').title()}")
        print(f"Fastest Test: {fastest_test.replace('_', ' ').title()}")
        
except Exception as e:
    print(f"Error creating performance dashboard: {e}")

Best Quality: Investment Recommendation
Fastest Test: Technical

import time
import yfinance as yf
import tempfile
import matplotlib
matplotlib.use('Agg')  # Use non-interactive backend
import matplotlib.pyplot as plt
import io
import contextlib
import sys
import traceback
from datetime import datetime
import gradio as gr

class DebugCapture:
    """Capture debug output from agents for real-time display"""
    
    def __init__(self):
        self.debug_log = []
        self.max_entries = 100  # Limit log size for performance
        
    def log(self, message, agent_type="SYSTEM"):
        """Add a debug message with timestamp"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        entry = f"[{timestamp}] [{agent_type}] {message}"
        self.debug_log.append(entry)
        
        # Keep only recent entries
        if len(self.debug_log) > self.max_entries:
            self.debug_log.pop(0)
    
    def get_log(self):
        """Get formatted debug log"""
        if not self.debug_log:
            return "No debug information yet. Start an analysis to see real-time agent activity."
        
        return "\n".join(self.debug_log)
    
    def clear(self):
        """Clear debug log"""
        self.debug_log = []

class GradioInvestmentInterface:
    """Gradio UI with Debug Output"""
    
    def __init__(self, main_agent, routing_coordinator, news_chain):
        """Initialize with required agent components"""
        self.main_research_agent = main_agent
        self.routing_coordinator = routing_coordinator
        self.news_chain = news_chain
        self.debug_capture = DebugCapture()
        
        # Set up visualization for non-interactive use
        plt.ioff()  # Turn off interactive mode
        plt.style.use('default')
    
    def extract_investment_recommendation(self, analysis_data, symbol):
        """Extract and format investment recommendation with emojis"""
        try:
            # Initialize default recommendation
            recommendation_data = {
                'action': 'HOLD',
                'confidence': 'Medium',
                'target_price': 'N/A',
                'risk_level': 'Medium',
                'time_horizon': 'Medium-term',
                'reasoning': 'Analysis completed but specific recommendation not found.'
            }
            
            # Search for recommendation in different analysis types
            recommendation_text = ""
            
            # Check if it's from routing results (has specialist_analyses)
            if isinstance(analysis_data, dict) and 'specialist_analyses' in analysis_data:
                specialists = analysis_data['specialist_analyses']
                
                # Look for recommendation specialist first
                if 'recommendation' in specialists:
                    rec_analysis = specialists['recommendation']
                    if isinstance(rec_analysis, dict) and 'analysis' in rec_analysis:
                        recommendation_text = str(rec_analysis['analysis'])
                
                # If no recommendation specialist, check fundamental analysis
                elif 'fundamental' in specialists:
                    fund_analysis = specialists['fundamental']
                    if isinstance(fund_analysis, dict) and 'analysis' in fund_analysis:
                        recommendation_text = str(fund_analysis['analysis'])
                
                # Fallback to any available analysis
                else:
                    for specialist, data in specialists.items():
                        if isinstance(data, dict) and 'analysis' in data:
                            recommendation_text = str(data['analysis'])
                            break
            
            # Check if it's from comprehensive research results
            elif isinstance(analysis_data, dict) and 'routing_results' in analysis_data:
                routing_data = analysis_data['routing_results']
                return self.extract_investment_recommendation(routing_data, symbol)
            
            # Parse recommendation from text
            recommendation_text_lower = recommendation_text.lower()
            
            # Determine action based on keywords
            if any(word in recommendation_text_lower for word in ['buy', 'strong buy', 'bullish', 'undervalued', 'opportunity']):
                recommendation_data['action'] = 'BUY'
            elif any(word in recommendation_text_lower for word in ['sell', 'strong sell', 'bearish', 'overvalued', 'avoid']):
                recommendation_data['action'] = 'SELL'
            elif any(word in recommendation_text_lower for word in ['hold', 'maintain', 'neutral']):
                recommendation_data['action'] = 'HOLD'
            
            # Extract confidence level
            if any(word in recommendation_text_lower for word in ['high confidence', 'strong', 'very confident']):
                recommendation_data['confidence'] = 'High'
            elif any(word in recommendation_text_lower for word in ['low confidence', 'uncertain', 'cautious']):
                recommendation_data['confidence'] = 'Low'
            
            # Extract risk level
            if any(word in recommendation_text_lower for word in ['high risk', 'volatile', 'risky']):
                recommendation_data['risk_level'] = 'High'
            elif any(word in recommendation_text_lower for word in ['low risk', 'stable', 'conservative']):
                recommendation_data['risk_level'] = 'Low'
            
            # Try to extract target price and reasoning
            import re
            
            # Look for price targets
            price_patterns = [
                r'\$?(\d+(?:\.\d{2})?)',
                r'target.*?\$?(\d+(?:\.\d{2})?)',
                r'price.*?\$?(\d+(?:\.\d{2})?)'
            ]
            
            for pattern in price_patterns:
                matches = re.findall(pattern, recommendation_text_lower)
                if matches:
                    try:
                        target_price = float(matches[0])
                        recommendation_data['target_price'] = f"${target_price:.2f}"
                        break
                    except:
                        continue
            
            # Extract key reasoning points
            sentences = recommendation_text.split('.')
            key_points = []
            for sentence in sentences[:3]:  # Take first 3 sentences as key points
                sentence = sentence.strip()
                if len(sentence) > 20:  # Only meaningful sentences
                    key_points.append(sentence)
            
            if key_points:
                recommendation_data['reasoning'] = '. '.join(key_points) + '.'
            
            # Format the final recommendation with emojis
            action_emoji = {
                'BUY': '🚀',
                'SELL': '📉', 
                'HOLD': '⚖️'
            }
            
            risk_emoji = {
                'High': '🔴',
                'Medium': '🟡',
                'Low': '🟢'
            }
            
            confidence_emoji = {
                'High': '💪',
                'Medium': '👍',
                'Low': '🤔'
            }
            
            formatted_recommendation = f"""
## {action_emoji.get(recommendation_data['action'], '⚖️')} Investment Recommendation: **{recommendation_data['action']}**

### 📊 **Analysis Summary**
- **Stock Symbol:** {symbol.upper()}
- **Recommendation:** {recommendation_data['action']}
- **Target Price:** {recommendation_data['target_price']}
- **Risk Level:** {risk_emoji.get(recommendation_data['risk_level'], '🟡')} {recommendation_data['risk_level']}
- **Confidence:** {confidence_emoji.get(recommendation_data['confidence'], '👍')} {recommendation_data['confidence']}
- **Time Horizon:** {recommendation_data['time_horizon']}

### 🎯 **Key Investment Insights**
{recommendation_data['reasoning']}

### ⚠️ **Risk Disclosure**
This recommendation is based on AI analysis of available data and should not be considered as financial advice. Please conduct your own research and consult with financial professionals before making investment decisions.
            """
            
            return formatted_recommendation.strip()
            
        except Exception as e:
            self.debug_capture.log(f"Error extracting recommendation: {e}", "ERROR")
            return f"❌ **Error:** Unable to extract investment recommendation. Raw analysis available in the Investment Report tab."

    def analyze_stock(self, symbol, analysis_type="Quick Overview", include_visualizations=False):
        """Enhanced stock analysis with debug logging"""
        try:
            start_time = time.time()
            self.debug_capture.log(f"Starting analysis for {symbol} - Type: {analysis_type}", "ANALYSIS")
            
            # Capture stdout for agent debug output
            captured_output = io.StringIO()
            
            with contextlib.redirect_stdout(captured_output):
                self.debug_capture.log(f"Routing analysis request...", "ROUTING")
                
                # Route the analysis based on type
                if analysis_type == "Quick Overview":
                    research_results = self.routing_coordinator.route_analysis(
                        f"Quick analysis of {symbol} stock", 
                        symbol
                    )
                elif analysis_type == "Comprehensive Research":
                    research_results = self.routing_coordinator.route_analysis(
                        f"Comprehensive research and analysis of {symbol} stock with all specialists", 
                        symbol
                    )
                elif analysis_type == "Technical Analysis":
                    research_results = self.routing_coordinator.route_analysis(
                        f"Technical analysis of {symbol} with chart patterns and indicators", 
                        symbol
                    )
                elif analysis_type == "Fundamental Analysis":
                    research_results = self.routing_coordinator.route_analysis(
                        f"Fundamental analysis of {symbol} with financial metrics", 
                        symbol
                    )
                elif analysis_type == "News Sentiment":
                    research_results = self.routing_coordinator.route_analysis(
                        f"News sentiment analysis for {symbol} stock", 
                        symbol
                    )
                else:
                    research_results = self.routing_coordinator.route_analysis(
                        f"General analysis of {symbol} stock", 
                        symbol
                    )
            
            # Process analysis statistics
            analysis_stats = {
                'specialists_activated': [],
                'analysis_depth': 'Unknown',
                'data_sources': [],
                'models_used': set(),
                'analysis_iterations': 0,
                'quality_score': 'N/A'
            }
            
            if research_results and 'specialist_analyses' in research_results:
                specialists = research_results['specialist_analyses']
                
                # Get specialist information
                for specialist_name, data in specialists.items():
                    analysis_stats['specialists_activated'].append(specialist_name.title())
                    
                    # Track data sources and models
                    if isinstance(data, dict):
                        if 'data_sources' in data:
                            analysis_stats['data_sources'].extend(data['data_sources'])
                        if isinstance(data, dict) and 'model_used' in data:
                            analysis_stats['models_used'].add(data.get('model_used', 'Unknown'))
                
                # Get optimization stats
                optimization_results = research_results.get('optimization_results', {})
                if optimization_results:
                    analysis_stats['analysis_iterations'] = len(optimization_results.get('optimization_iterations', []))
                
                # Get quality score from self-reflection
                reflection = research_results.get('self_reflection', {})
                if reflection and 'overall_score' in reflection:
                    analysis_stats['quality_score'] = f"{reflection['overall_score']}/10"
            
            # Parse captured output for debug
            output_lines = captured_output.getvalue().split('\n')
            for line in output_lines:
                if line.strip() and not line.startswith('[GRADIO]'):
                    self.debug_capture.log(line.strip(), "AGENT")
            
            # Convert sets to lists for JSON serialization
            analysis_stats['data_sources'] = list(set(analysis_stats['data_sources']))
            analysis_stats['models_used'] = list(analysis_stats['models_used']) if analysis_stats['models_used'] else ['Azure GPT-4']
            
            # Create simple price chart only if explicitly requested
            price_chart = None
            if include_visualizations:
                try:
                    self.debug_capture.log("Creating price chart...", "VISUALIZATION")
                    print("[GRADIO] Creating price chart...")
                    price_chart = self.create_simple_price_chart(symbol)
                    self.debug_capture.log("Price chart created successfully", "VISUALIZATION")
                except Exception as e:
                    print(f"[GRADIO] Chart error: {e}")
                    self.debug_capture.log(f"Chart error: {e}", "ERROR")
                    price_chart = None
            
            # Enhanced summary with detailed statistics
            execution_time = time.time() - start_time
            
            summary = f"""
## 📊 **Analysis Summary for {symbol.upper()}**

### 🔍 **Analysis Configuration**
- **Type:** {analysis_type}
- **Execution Time:** {execution_time:.2f} seconds
- **Specialists Activated:** {', '.join(analysis_stats['specialists_activated']) if analysis_stats['specialists_activated'] else 'None'}
- **Quality Score:** {analysis_stats['quality_score']}
- **AI Models Used:** {', '.join(analysis_stats['models_used'])}

### 📈 **Data Sources**
{', '.join(analysis_stats['data_sources']) if analysis_stats['data_sources'] else 'Standard market data sources'}

### ⚡ **Performance Metrics**
- **Analysis Iterations:** {analysis_stats['analysis_iterations']}
- **Response Time:** {execution_time:.2f}s
- **Status:** ✅ Completed Successfully

### 🎯 **Next Steps**
1. Review the detailed investment recommendation in the first tab
2. Examine the comprehensive report for full analysis
3. Check debug output for technical details
4. Consider the risk factors and your investment timeline

*Analysis completed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
            """
            
                    # Generate final report
            if research_results:
                try:
                    self.debug_capture.log("Generating final investment report...", "REPORTING")
                    print("[GRADIO] Generating report...")
                    
                    # Try the primary summarized report method first
                    try:
                        investment_report = self.main_research_agent.generate_summarized_report(research_results, symbol)
                        self.debug_capture.log("Summarized report generated successfully", "REPORTING")
                    except AttributeError as summ_err:
                        self.debug_capture.log(f"AttributeError in summarized report generation: {summ_err}", "WARNING")
                        
                        # Try the standard investment report method
                        try:
                            investment_report = self.main_research_agent.generate_investment_report(research_results)
                            self.debug_capture.log("Investment report generated successfully", "REPORTING")
                        except AttributeError as inv_err:
                            self.debug_capture.log(f"AttributeError in investment report generation: {inv_err}", "WARNING")
                            
                            # Final fallback to routing report
                            try:
                                investment_report = self.main_research_agent.generate_routing_report(research_results, symbol, analysis_type)
                                self.debug_capture.log("Routing report generated successfully", "REPORTING")
                            except AttributeError as route_err:
                                self.debug_capture.log(f"All report generation methods failed", "ERROR")
                                self.debug_capture.log(f"Main agent type: {type(self.main_research_agent)}", "DEBUG")
                                self.debug_capture.log(f"Available methods: {dir(self.main_research_agent)}", "DEBUG")
                                
                                # Last resort fallback
                                investment_report = f"""
## Investment Report (Fallback)

### Analysis Summary
The system was able to collect data for {symbol}, but encountered errors with report generation.
                        
### Available Research Data
```
{str(research_results)[:500]}... (truncated)
```

Please check the debug tab for more information about this error.
"""
                    
                    # Check if investment report is empty or None and handle it
                    if not investment_report or investment_report.strip() == "":
                        investment_report = "## Investment Report\n\nThe AI agent was unable to generate a detailed report. Please check the debug log for more information."
                        self.debug_capture.log("Warning: Empty investment report detected", "WARNING")
                    
                except Exception as e:
                    self.debug_capture.log(f"Report generation error: {e}", "ERROR")
                    investment_report = f"""
## Report Generation Failed

**Error:** {str(e)}

The system encountered an error while trying to generate the investment report. This could be due to:
- Insufficient data gathered during analysis
- Internal processing error
- Connection issues with data sources

Please try again or select a different analysis type.
"""
            else:
                investment_report = "No analysis results available for report generation."
            # Extract recommendation
            recommendation = self.extract_investment_recommendation(research_results, symbol)
            
            execution_time = time.time() - start_time
            self.debug_capture.log(f"Analysis completed for {symbol} in {execution_time:.2f}s", "ANALYSIS")
            print(f"[GRADIO] Analysis completed for {symbol} in {execution_time:.2f}s")
            
            return (
                recommendation,  # recommendation_output
                self.debug_capture.get_log(),  # debug_output
                summary,  # summary_output
                investment_report,  # report_output
                price_chart,  # price_plot
                "✅ Analysis completed successfully!"  # progress_status
            )
            
        except Exception as e:
            error_msg = f"Analysis failed: {str(e)}"
            self.debug_capture.log(f"ERROR: {error_msg}", "ERROR")
            print(f"[GRADIO] Error: {error_msg}")
            
            return (
                f"❌ **Analysis Error:** {error_msg}",  # recommendation_output
                self.debug_capture.get_log(),  # debug_output
                f"❌ **Error:** Analysis failed for {symbol}",  # summary_output
                f"**Error Report:** {error_msg}",  # report_output
                None,  # price_plot
                f"❌ Error: {error_msg}"  # progress_status
            )

    def create_simple_price_chart(self, symbol):
        """Create a simple price chart for visualization"""
        try:
            # Get stock data
            stock = yf.Ticker(symbol)
            hist = stock.history(period="6mo")
            
            if hist.empty:
                return None
            
            # Create simple plot
            fig, ax = plt.subplots(figsize=(10, 6))
            ax.plot(hist.index, hist['Close'], linewidth=2, color='#1f77b4')
            ax.set_title(f'{symbol.upper()} - 6 Month Price Chart', fontsize=14, fontweight='bold')
            ax.set_xlabel('Date')
            ax.set_ylabel('Price ($)')
            ax.grid(True, alpha=0.3)
            
            # Format dates
            import matplotlib.dates as mdates
            ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d'))
            ax.xaxis.set_major_locator(mdates.MonthLocator())
            plt.xticks(rotation=45)
            
            # Save with minimal settings for speed
            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
            fig.savefig(temp_file.name, format='png', bbox_inches='tight', dpi=72, facecolor='white')
            plt.close(fig)
            
            return temp_file.name
            
        except Exception as e:
            print(f"[GRADIO] Price chart error: {e}")
            plt.close('all')  # Clean up any open figures
            return None

    def create_gradio_interface(self):
        """Create fast and responsive Gradio interface with enhanced debug output"""
        
        with gr.Blocks(title="AI Investment Research Agent", theme=gr.themes.Soft()) as demo:
            gr.Markdown("""
            # 🤖 AI Investment Research Agent
            
            Get comprehensive investment analysis powered by multiple AI specialists including fundamental analysis, 
            technical analysis, news sentiment, and market research.
            
            **Features:**
            - 🎯 AI-powered investment recommendations
            - 📊 Multi-specialist analysis (Technical, Fundamental, News, etc.)
            - 📈 Real-time price charts                        
            - ⚡ Deep analysis with optimization and self-reflection
            - 🔍 Detailed debug output and agent activity tracking
            """)
            
            with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("## 🎯 Analysis Configuration")
                    
                    symbol_input = gr.Textbox(
                        label="Stock Symbol",
                        placeholder="Enter stock symbol (e.g., AAPL, TSLA, MSFT)",
                        value="AAPL"
                    )
                    
                    analysis_type = gr.Dropdown(
                        choices=[
                            "Quick Overview",
                            "Comprehensive Research", 
                            "Technical Analysis",
                            "Fundamental Analysis",
                            "News Sentiment"
                        ],
                        label="Analysis Type",
                        value="Quick Overview"
                    )
                    
                    include_viz = gr.Checkbox(
                        label="Include Price Chart",
                        value=True
                    )
                    
                    analyze_btn = gr.Button("🚀 Start Analysis", variant="primary", size="lg")
                    
                    progress_status = gr.Textbox(
                        value="",
                        visible=True,
                        label="Analysis Progress"
                    )
                    
                    # Fixed: Removed the 'elem_id' parameter that was causing the error
                    progress_bar = gr.Progress(
                        track_tqdm=True
                    )
                    
                    # Debug controls
                    gr.Markdown("## 🔧 Debug Controls")
                    clear_debug_btn = gr.Button("🗑️ Clear Debug Log", size="sm")
                
                with gr.Column(scale=2):
                    gr.Markdown("## 📈 Results")
                    
                    with gr.Tabs():
                        with gr.TabItem("🎯 Investment Recommendation"):
                            gr.Markdown("**AI Investment Recommendation with Risk Assessment**")
                            recommendation_output = gr.Markdown(value="Click 'Start Analysis' to get investment recommendation...")
                        with gr.TabItem("📊 Investment Report"):
                            gr.Markdown("**Comprehensive Investment Research Report**")
                            report_output = gr.Markdown(value="Click 'Start Analysis' to begin...", elem_id="investment_report")
                        with gr.TabItem("📊 Price Chart"):
                            price_plot = gr.Image(label="Stock Price Chart")
                        with gr.TabItem("🔍 Debug Output"):
                            gr.Markdown("**Real-time Agentic Debug Information**")
                            debug_output = gr.Textbox(
                                label="Debug Log",
                                value="No debug information yet. Start an analysis to see real-time agent activity.",
                                lines=50,
                                max_lines=100,
                                interactive=True,
                                show_copy_button=True,
                                autoscroll=True,
                                container=True,
                                scale=2
                            )
                            # Add refresh button for debug log
                            with gr.Row():
                                refresh_debug_btn = gr.Button("🔄 Refresh Debug Log", size="sm")
                                auto_scroll_toggle = gr.Checkbox(
                                    label="Auto-scroll to bottom",
                                    value=True
                                )
                        with gr.TabItem("📈 Summary"):
                            summary_output = gr.Markdown(value="Analysis summary will appear here...")

            
            # Simple and fast event handler
            def run_analysis(symbol, analysis_type, include_viz):
                """Run stock analysis with progress updates"""
                progress = gr.Progress()
                try:
                    if not symbol or len(symbol.strip()) < 1:
                        return (
                            "❌ **Error:** Please enter a valid stock symbol.",
                            self.debug_capture.get_log(),
                            "❌ **Error:** Invalid symbol provided.",
                            "**Error:** No symbol provided for analysis.",
                            None,
                            "❌ Error: Invalid symbol"
                        )
                    
                    symbol = symbol.strip().upper()
                    
                    # Update progress status with search starting
                    progress(0, desc=f"Starting analysis for {symbol}")
                    
                    # Add steps for the progress bar
                    progress(0.1, desc=f"Initializing analysis for {symbol}")
                    time.sleep(0.5)  # Small delay for UI feedback
                    
                    progress(0.2, desc="Routing analysis request...")
                    time.sleep(0.5)  # Small delay for UI feedback
                    
                    progress(0.3, desc="Processing data...")
                    
                    # Perform the actual analysis (this function itself takes time)
                    result = self.analyze_stock(symbol, analysis_type, include_viz)
                    
                    progress(0.9, desc="Finalizing report...")
                    time.sleep(0.5)  # Small delay for UI feedback
                    
                    progress(1.0, desc="Analysis complete!")
                    return result
                    
                except Exception as e:
                    progress(1.0, desc="Analysis failed!")
                    return (
                        f"❌ **Error:** {str(e)}",  # recommendation
                        self.debug_capture.get_log(),  # debug
                        f"❌ **Error:** {str(e)}",  # summary  
                        f"**Error:** {str(e)}",  # report
                        None,  # chart
                        gr.update(value=f"❌ **Error:** {str(e)}", visible=True)  # progress
                    )
            
            def clear_debug():
                """Clear debug log"""
                self.debug_capture.clear()
                return "Debug log cleared."
            
            def refresh_debug():
                """Refresh debug log display"""
                return self.debug_capture.get_log()
            
            analyze_btn.click(
                fn=run_analysis,
                inputs=[symbol_input, analysis_type, include_viz],
                outputs=[recommendation_output, debug_output, summary_output, report_output, price_plot, progress_status]
            )
            
            clear_debug_btn.click(
                fn=clear_debug,
                outputs=[debug_output]
            )
            
            refresh_debug_btn.click(
                fn=refresh_debug,
                outputs=[debug_output]
            )            
        
        return demo

# Initialize optimized interface
print("[GRADIO] Initializing optimized interface with debug capture...")
investment_interface = GradioInvestmentInterface(
    main_research_agent, 
    routing_coordinator, 
    news_chain
)

print("[GRADIO] Creating interface...")
gradio_demo = investment_interface.create_gradio_interface()
print("[GRADIO] Interface ready! Use gradio_demo.launch() to start.")

[GRADIO] Initializing optimized interface with debug capture...
[GRADIO] Creating interface...
[GRADIO] Interface ready! Use gradio_demo.launch() to start.

# Launch the Gradio interface using the combined class
if __name__ == "__main__":
    try:
        print("🚀 Launching Investment Research Agent Interface...")
        print("🔧 Initializing Gradio components...")
        
        # Check if interface was created successfully
        if gradio_demo is None:
            print("❌ Error: Gradio interface not initialized")
            raise Exception("Interface initialization failed")
        
        print("✅ Interface ready, starting server...")
        
        # Launch with improved configuration
        gradio_demo.launch(
            server_name="127.0.0.1",
            server_port=7860,
            share=False,
            debug=True,
            show_error=True,
            quiet=False,
            inbrowser=True
        )
        
    except Exception as e:
        print(f"❌ Error launching Gradio interface: {e}")
        print("🔄 Attempting fallback launch...")
        
        # Fallback launch with minimal configuration
        try:
            gradio_demo.launch(
                share=False, 
                debug=True,
                show_error=True
            )
        except Exception as fallback_error:
            print(f"❌ Fallback launch failed: {fallback_error}")
            print("💡 Troubleshooting tips:")
            print("   - Check if port 7860 is available")
            print("   - Try restarting the notebook kernel")
            print("   - Ensure all dependencies are installed")
            
            # Final attempt with auto port selection
            try:
                print("🔄 Final attempt: Auto-selecting available port...")
                gradio_demo.launch(
                    share=False,
                    debug=False,
                    show_error=True,
                    server_port=None  # Let Gradio choose port
                )
            except Exception as final_error:
                print(f"🚫 All launch attempts failed: {final_error}")
                print("Please check the error details above for troubleshooting.")

🚀 Launching Investment Research Agent Interface...
🔧 Initializing Gradio components...
✅ Interface ready, starting server...
* Running on local URL:  http://127.0.0.1:7860
* Running on local URL:  http://127.0.0.1:7860
* To create a public link, set `share=True` in `launch()`.
* To create a public link, set `share=True` in `launch()`.

[GRADIO] Creating price chart...
[GRADIO] Generating report...
[SUMMARIZER] Generating executive summary report | Symbol: AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 707 | Context: News & Sentiment Summary Summary for AAPL
[AGENT] Model: gpt-4.1-nano-2025-04-14 | Tokens: 645 | Context: SEC Filings & Regulatory Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 734 | Context: Fundamental Analysis Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 808 | Context: Technical Analysis Summary Summary for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 1117 | Context: Investment Recommendation Summary Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1357 | Context: Executive Summary for AAPL
[SUMMARIZER] Report generation completed successfully
[GRADIO] Analysis completed for AAPL in 71.86s
[GRADIO] Creating price chart...
[GRADIO] Generating report...
[SUMMARIZER] Generating executive summary report | Symbol: AAPL
[AGENT] Model: gpt-4.1-nano-2025-04-14 | Tokens: 661 | Context: News & Sentiment Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 708 | Context: SEC Filings & Regulatory Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 741 | Context: Fundamental Analysis Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 798 | Context: Technical Analysis Summary Summary for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 1112 | Context: Investment Recommendation Summary Summary for AAPL
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1341 | Context: Executive Summary for AAPL
[SUMMARIZER] Report generation completed successfully
[GRADIO] Analysis completed for AAPL in 63.85s
[GRADIO] Creating price chart...
[GRADIO] Generating report...
[SUMMARIZER] Generating executive summary report | Symbol: AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 834 | Context: News & Sentiment Summary Summary for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 1013 | Context: SEC Filings & Regulatory Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 734 | Context: Fundamental Analysis Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 797 | Context: Technical Analysis Summary Summary for AAPL
[AGENT] Model: gpt-5-nano-2025-08-07 | Tokens: 1236 | Context: Investment Recommendation Summary Summary for AAPL
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 1365 | Context: Executive Summary for AAPL
[SUMMARIZER] Report generation completed successfully
[GRADIO] Analysis completed for AAPL in 74.09s
[GRADIO] Creating price chart...
[GRADIO] Generating report...
[SUMMARIZER] Generating executive summary report | Symbol: MSFT
[AGENT] Model: gpt-4.1-nano-2025-04-14 | Tokens: 704 | Context: Fundamental Analysis Summary Summary for MSFT
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 668 | Context: News & Sentiment Summary Summary for MSFT
[AGENT] Model: gpt-4.1-mini-2025-04-14 | Tokens: 803 | Context: Technical Analysis Summary Summary for MSFT
[AGENT] Model: gpt-4.1-nano-2025-04-14 | Tokens: 700 | Context: Investment Recommendation Summary Summary for MSFT
[AGENT] Model: gpt-5-mini-2025-08-07 | Tokens: 1154 | Context: Executive Summary for MSFT
[SUMMARIZER] Report generation completed successfully
[GRADIO] Analysis completed for MSFT in 130.64s

Investment Research Agent - Multi-Agent System¶

Index¶

1. Project Overview ⇧¶

Key Features¶

Three Agentic Workflow Patterns¶

Business Value¶

2. Architecture ⇧¶

Core Architecture Components¶

1. Agent Memory System (FAISS Vector Database)¶

2. Data Integration Layer¶

3. Specialist Agent Network¶

4. Three Core Workflow Patterns¶

5. Coordination Layer¶

6. User Interface¶

Key Features¶

Technology Stack¶

Key Sequence Flow:¶

3. Environment Setup and Dependencies ⇧¶

4. Vector Database and Memory System ⇧¶

Vector Database Implementation Overview¶

5. Data Source Tools and Integrations ⇧¶

Data Source Tools and Integrations Overview¶

1. Yahoo Finance Tool (get_stock_data)¶

2. News API Tool (get_stock_news)¶

3. FRED Economic Data Tool (get_economic_data)¶

4. Alpha Vantage Tool (get_alpha_vantage_data)¶

5. SEC Filings Tool (get_sec_filings)¶

6. Investment Recommendation Tool (get_investment_recommendation)¶

6. Base Agent Class and Prompt Configurations ⇧¶

Prompts and Prompt Engineering Techniques¶

7. Workflow Pattern 1: Prompt Chaining (News Processing Pipeline) ⇧¶

Workflow Pattern 1: Prompt Chaining - News Processing Pipeline¶

Sequential Processing Pipeline¶

Prompt Chaining Implementation¶

8. Workflow Pattern 2: Routing (Specialist Agents) ⇧¶

Workflow Pattern 2: Routing (Specialist Agents)¶

Intelligent Routing System¶

Specialist Agent Network¶

9. Workflow Pattern 3: Evaluator-Optimizer (Analysis Refinement Loop) ⇧¶

Workflow Pattern 3: Evaluator-Optimizer (Analysis Refinement Loop)¶

Iterative Refinement Process¶

Quality Assurance Mechanisms¶

10. Summarizer Agent - Executive Report Generation ⇧¶

Summarizer Agent - Executive Report Generation¶

11. Main Investment Research Agent Coordinator ⇧¶

12. Agent Testing ⇧¶

Test Types Overview¶

Test 1: Quick Analysis¶

Test 1 Results: Quick Analysis Assessment - Multi-Specialist Coordination¶

Performance Metrics¶

Key Test Insights¶

Bottom Line¶

Test 2: Comprehensive Analysis (Full System Test)¶

Test 2 Results: Comprehensive Analysis - System Integration Performance¶

Success Metrics¶

Key Performance Insights¶

Bottom Line¶

Test 3: Technical Analysis¶

Test 3 Results: Technical Analysis - Focused Specialist Routing¶

Performance Metrics¶

Key Test Insights¶

Bottom Line¶

Test 4: Fundamental Analysis¶

Test 4 Results: Fundamental Analysis - Multi-Specialist Coordination¶

Performance Metrics¶

Key Test Insights¶

Bottom Line¶

Test 5: News & Sentiment Analysis¶

Test 5 Results: News & Sentiment Analysis - Multi-Modal Data Processing¶

Performance Metrics¶

Key Test Insights¶

Bottom Line¶

Test 6: Investment Recommendation Analysis¶

Test 6 Results: Investment Recommendation Analysis - Comprehensive Rating Generation¶

Performance Metrics¶

Key Test Insights¶

Bottom Line¶

Testing Summary & Results¶

Test Results Visualization¶

Test Results Analysis¶

1. Yahoo Finance Tool (`get_stock_data`)¶

2. News API Tool (`get_stock_news`)¶

3. FRED Economic Data Tool (`get_economic_data`)¶

4. Alpha Vantage Tool (`get_alpha_vantage_data`)¶

5. SEC Filings Tool (`get_sec_filings`)¶

6. Investment Recommendation Tool (`get_investment_recommendation`)¶